﻿# 导入库模块
import pandas as pd
import numpy as np

# 定义带逗号、乘号字符串解析函数
def 逗号乘号分隔函数(字符串序列):
    逗号分隔 = pd.Series(字符串序列.split(','))
    逗号乘号分隔 = []
    for i in range(len(逗号分隔)):
        if (逗号分隔.str.contains('×', na=False))[i]:
            乘号分隔 = (逗号分隔[i]).split('×')
            for j in range(int(乘号分隔[0])):
                逗号乘号分隔.append(乘号分隔[1])
        else:
            逗号乘号分隔.append(逗号分隔[i])
    return 逗号乘号分隔

# 定义列表去重函数
def 列表去重(序列):
    删除 = []
    for i in range(1, len(序列)):
        if 序列[i] == 序列[i - 1]:
            删除.append(i)
    for i in range(len(删除)):
        del 序列[删除[i]]
    return 序列

# 定义判断位置在序列中下标函数
def 判断位置在序列中下标(位置,序列):
    下标 = int(0)
    if 位置 <= 序列[0]:
        下标 = 0
        return 下标
    elif 序列[len(序列) - 2] < 位置 <= 序列[len(序列) - 1]:
        下标 = len(序列) - 1
        return 下标
    else:
        for i in range(1,len(序列)-1):
            if 序列[i - 1] < 位置 <= 序列[i]:
                下标 = i
        return 下标

# 定义相对位置间距转换为绝对位置序列函数
def 相对位置转绝对(序列):
    绝对位置 = []
    绝对位置0 = float(0)
    for i in range(len(序列)):
        绝对位置0 = 绝对位置0 + 序列[i]
        绝对位置.append(绝对位置0)
    return 绝对位置

# 定义判断主梁截面位置在序列中下标函数
def 获取主梁截面特征去重下标(主梁截面特性,主梁截面特征_去重):
    for i in range(主梁截面特征_去重.shape[0]):
        判断 = 1
        for j in range(len(主梁截面特性)):
            if 主梁截面特性[j] != 主梁截面特征_去重.iloc[i][j]:
                判断 = 0
                break
        if 判断 == 1:
            return i

# 读取参数
Route = 'C:\PY\钢板组合梁.xlsx'
参数表 = pd.read_excel(Route,sheet_name='钢板组合梁',index_col= None,header = None)
参数表 = 参数表.dropna(how='all')
总体信息 = {'桥梁跨度':'','桥面宽度':'','主梁片数':'','主梁横向间距':'','伸缩缝宽':''}
桥面板 = {'桥面板厚度':0,'纵向上缘钢筋':0,'纵向下缘钢筋':0,'横向上缘钢筋':0,'横向下缘钢筋':0}
主梁 = {'钢主梁高度':0,'上翼缘宽度':0,'下翼缘宽度':0,'主梁加工分段序列':0,'主梁一处拼接板重':0}
主梁板厚 = {'顶板长度序列':0,'顶板厚度序列':0,'底板长度序列':0,'底板厚度序列':0,'腹板长度序列':0,'腹板厚度序列':0}
小纵梁 = {'小纵梁(HW型钢)':0,'腹板横肋(长×宽×厚)':0}
工字形横梁0 = {'工字形横梁': 0, '上翼缘宽度': 0, '上翼缘厚度': 0, '下翼缘宽度': 0,'下翼缘厚度':0, '腹板高度': 0, '腹板厚度': 0,
            '顶缘距主梁顶距离': 0, '腹板横肋间距序列': 0, '腹板横肋(长×宽×厚)': 0, '横梁一端拼接重': 0, '备注': 0}
工字形横梁 = []
K形桁架式横梁0 = {'K形桁架式横梁': 0, '上横梁(HW型钢)': 0, '下横梁(HW型钢)': 0, '斜撑(F型钢)': 0,'上横梁顶距主梁顶距离':0,
              '下横梁顶距主梁顶距离':0,'上横梁一端拼接重': 0, '上横梁中间拼接1/2重': 0,'下横梁一端拼接重': 0,'备注': 0}
K形桁架式横梁 = []
横梁布置 = {'横梁位置序列':0,'横梁样式序列':0}
主梁腹板纵肋设置0 = {'板肋': 0, '加劲肋宽度': 0, '加劲肋厚度': 0, '距顶端距离': 0, '纵向范围': 0,'备注':0}
主梁腹板纵肋设置 = []
主梁腹板横肋设置 = {'端横梁间横肋数':0,'其他横梁间横肋数':0,'腹板横肋(长×宽×厚)':0}
支座布置0 = {'支座距离序列': 0, '支座加劲肋位置序列': 0, '支座加劲肋(长×宽×厚)': 0,'支座垫板(长×宽×厚)':0}
支座布置 = []
荷载信息 = {'护栏荷载':0,'铺装荷载':0,'整体升温':0,'整体降温':0,'温度梯度升温T1':0,'温度梯度升温T2':0,'不均匀沉降':0}
i = int(0)
while 参数表.iloc[i][0] != '13.结束':
    if 参数表.iloc[i][0] == '1.总体信息':
        总体信息['桥梁跨度'] = 参数表.iloc[i+2][0]
        总体信息['桥面宽度'] = 参数表.iloc[i+2][1]
        总体信息['主梁片数'] = 参数表.iloc[i+2][2]
        总体信息['主梁横向间距'] = 参数表.iloc[i+2][3]
        总体信息['伸缩缝宽'] = 参数表.iloc[i+2][4]
    elif 参数表.iloc[i][0] == '2.桥面板':
        桥面板['桥面板厚度'] = 参数表.iloc[i+2][0]
        桥面板['纵向上缘钢筋'] = 参数表.iloc[i+2][1]
        桥面板['纵向下缘钢筋'] = 参数表.iloc[i+2][2]
        桥面板['横向上缘钢筋'] = 参数表.iloc[i+2][3]
        桥面板['横向下缘钢筋'] = 参数表.iloc[i+2][4]
    elif 参数表.iloc[i][0] == '3.主梁':
        主梁['钢主梁高度'] = 参数表.iloc[i + 2][0]
        主梁['上翼缘宽度'] = 参数表.iloc[i + 2][1]
        主梁['下翼缘宽度'] = 参数表.iloc[i + 2][2]
        主梁['主梁加工分段序列'] = 参数表.iloc[i + 2][3]
        主梁['主梁一处拼接板重'] = 参数表.iloc[i + 2][4]
    elif 参数表.iloc[i][0] == '4.主梁板厚':
        主梁板厚['顶板长度序列'] = 参数表.iloc[i + 2][0]
        主梁板厚['顶板厚度序列'] = 参数表.iloc[i + 2][1]
        主梁板厚['底板长度序列'] = 参数表.iloc[i + 2][2]
        主梁板厚['底板厚度序列'] = 参数表.iloc[i + 2][3]
        主梁板厚['腹板长度序列'] = 参数表.iloc[i + 2][4]
        主梁板厚['腹板厚度序列'] = 参数表.iloc[i + 2][5]
    elif 参数表.iloc[i][0] == '5.小纵梁':
        小纵梁['小纵梁(HW型钢)'] = 参数表.iloc[i + 2][0]
        小纵梁['腹板横肋(长×宽×厚)'] = 参数表.iloc[i + 2][1]
    elif 参数表.iloc[i][0] == '6.工字形横梁':
        工字形横梁数 = int(2)
        while 参数表.iloc[i+工字形横梁数][0] != '7.K形桁架式横梁':
            工字形横梁0['工字形横梁'] = 参数表.iloc[i+工字形横梁数][0]
            工字形横梁0['上翼缘宽度'] = 参数表.iloc[i+工字形横梁数][1]
            工字形横梁0['上翼缘厚度'] = 参数表.iloc[i+工字形横梁数][2]
            工字形横梁0['下翼缘宽度'] = 参数表.iloc[i+工字形横梁数][3]
            工字形横梁0['下翼缘厚度'] = 参数表.iloc[i+工字形横梁数][4]
            工字形横梁0['腹板高度'] = 参数表.iloc[i + 工字形横梁数][5]
            工字形横梁0['腹板厚度'] = 参数表.iloc[i + 工字形横梁数][6]
            工字形横梁0['顶缘距主梁顶距离'] = 参数表.iloc[i + 工字形横梁数][7]
            工字形横梁0['腹板横肋间距序列'] = 参数表.iloc[i + 工字形横梁数][8]
            工字形横梁0['腹板横肋(长×宽×厚)'] = 参数表.iloc[i + 工字形横梁数][9]
            工字形横梁0['横梁一端拼接重'] = 参数表.iloc[i + 工字形横梁数][10]
            工字形横梁0['备注'] = 参数表.iloc[i + 工字形横梁数][11]
            工字形横梁.append([工字形横梁0['工字形横梁'],工字形横梁0['上翼缘宽度'],工字形横梁0['上翼缘厚度'],
                            工字形横梁0['下翼缘宽度'],工字形横梁0['下翼缘厚度'],工字形横梁0['腹板高度'],
                           工字形横梁0['腹板厚度'],工字形横梁0['顶缘距主梁顶距离'],工字形横梁0['腹板横肋间距序列'],
                           工字形横梁0['腹板横肋(长×宽×厚)'],工字形横梁0['横梁一端拼接重'],工字形横梁0['备注']])
            工字形横梁数 = 工字形横梁数+1
        工字形横梁 = pd.DataFrame(工字形横梁,columns=['工字形横梁','上翼缘宽度','上翼缘厚度','下翼缘宽度','下翼缘厚度',
                               '腹板高度','腹板厚度','顶缘距主梁顶距离','腹板横肋间距序列','腹板横肋(长×宽×厚)','横梁一端拼接重','备注'])
    elif 参数表.iloc[i][0] == '7.K形桁架式横梁':
        K形横梁数 = int(2)
        while 参数表.iloc[i+K形横梁数][0] != '8.横梁布置':
            K形桁架式横梁0['K形桁架式横梁'] = 参数表.iloc[i+K形横梁数][0]
            K形桁架式横梁0['上横梁(HW型钢)'] = 参数表.iloc[i+K形横梁数][1]
            K形桁架式横梁0['下横梁(HW型钢)'] = 参数表.iloc[i+K形横梁数][2]
            K形桁架式横梁0['斜撑(F型钢)'] = 参数表.iloc[i+K形横梁数][3]
            K形桁架式横梁0['上横梁顶距主梁顶距离'] = 参数表.iloc[i+K形横梁数][4]
            K形桁架式横梁0['下横梁顶距主梁顶距离'] = 参数表.iloc[i + K形横梁数][5]
            K形桁架式横梁0['上横梁一端拼接重'] = 参数表.iloc[i + K形横梁数][6]
            K形桁架式横梁0['上横梁中间拼接1/2重'] = 参数表.iloc[i + K形横梁数][7]
            K形桁架式横梁0['下横梁一端拼接重'] = 参数表.iloc[i + K形横梁数][8]
            K形桁架式横梁0['备注'] = 参数表.iloc[i + K形横梁数][9]
            K形桁架式横梁.append([K形桁架式横梁0['K形桁架式横梁'],K形桁架式横梁0['上横梁(HW型钢)'],K形桁架式横梁0['下横梁(HW型钢)'],
                              K形桁架式横梁0['斜撑(F型钢)'],K形桁架式横梁0['上横梁顶距主梁顶距离'], K形桁架式横梁0['下横梁顶距主梁顶距离'],
                              K形桁架式横梁0['上横梁一端拼接重'],K形桁架式横梁0['上横梁中间拼接1/2重'],
                              K形桁架式横梁0['下横梁一端拼接重'],K形桁架式横梁0['备注']])
            K形横梁数 = K形横梁数+1
        K形桁架式横梁 = pd.DataFrame(K形桁架式横梁,columns=['K形桁架式横梁','上横梁(HW型钢)','下横梁(HW型钢)','斜撑(F型钢)',
                                                '上横梁顶距主梁顶距离','下横梁顶距主梁顶距离','上横梁一端拼接重','上横梁中间拼接1/2重',
                                                '下横梁一端拼接重','备注'])
    elif 参数表.iloc[i][0] == '8.横梁布置':
        横梁布置['横梁位置序列'] = 参数表.iloc[i + 2][0]
        横梁布置['横梁样式序列'] = 参数表.iloc[i + 2][1]
    elif 参数表.iloc[i][0] == '9.主梁腹板纵肋设置':
        纵肋数 = int(2)
        while 参数表.iloc[i+纵肋数][0] != '10.主梁腹板横肋设置':
            主梁腹板纵肋设置0['板肋'] = 参数表.iloc[i+纵肋数][0]
            主梁腹板纵肋设置0['加劲肋宽度'] = 参数表.iloc[i+纵肋数][1]
            主梁腹板纵肋设置0['加劲肋厚度'] = 参数表.iloc[i+纵肋数][2]
            主梁腹板纵肋设置0['距顶端距离'] = 参数表.iloc[i + 纵肋数][3]
            主梁腹板纵肋设置0['纵向范围'] = 参数表.iloc[i + 纵肋数][4]
            主梁腹板纵肋设置0['备注'] = 参数表.iloc[i + 纵肋数][5]
            主梁腹板纵肋设置.append([主梁腹板纵肋设置0['板肋'],主梁腹板纵肋设置0['加劲肋宽度'],主梁腹板纵肋设置0['加劲肋厚度'],
                             主梁腹板纵肋设置0['距顶端距离'],主梁腹板纵肋设置0['纵向范围'],主梁腹板纵肋设置0['备注']])
            纵肋数 = 纵肋数+1
        主梁腹板纵肋设置 = pd.DataFrame(主梁腹板纵肋设置,columns=['板肋','加劲肋宽度','加劲肋厚度','距顶端距离','纵向范围','备注'])
    elif 参数表.iloc[i][0] == '10.主梁腹板横肋设置':
        主梁腹板横肋设置['端横梁间横肋数'] = 参数表.iloc[i + 2][0]
        主梁腹板横肋设置['其他横梁间横肋数'] = 参数表.iloc[i + 2][1]
        主梁腹板横肋设置['腹板横肋(长×宽×厚)'] = 参数表.iloc[i + 2][2]
    elif 参数表.iloc[i][0] == '11.支座布置':
        支座数 = int(2)
        while 参数表.iloc[i+支座数][0] != '12.荷载信息':
            支座布置0['支座距离序列'] = 参数表.iloc[i+支座数][0]
            支座布置0['支座加劲肋位置序列'] = 参数表.iloc[i+支座数][1]
            支座布置0['支座加劲肋(长×宽×厚)'] = 参数表.iloc[i+支座数][2]
            支座布置0['支座垫板(长×宽×厚)'] = 参数表.iloc[i + 支座数][3]
            支座布置.append([支座布置0['支座距离序列'],支座布置0['支座加劲肋位置序列'],支座布置0['支座加劲肋(长×宽×厚)'],
                         支座布置0['支座垫板(长×宽×厚)']])
            支座数 = 支座数+1
        支座布置 = pd.DataFrame(支座布置,columns=['支座距离序列','支座加劲肋位置序列','支座加劲肋(长×宽×厚)','支座垫板(长×宽×厚)'])
    elif 参数表.iloc[i][0] == '12.荷载信息':
        荷载信息['护栏荷载'] = 参数表.iloc[i + 2][0]
        荷载信息['铺装荷载'] = 参数表.iloc[i + 2][1]
        荷载信息['整体升温'] = 参数表.iloc[i + 2][2]
        荷载信息['整体降温'] = 参数表.iloc[i + 2][3]
        荷载信息['温度梯度升温T1'] = 参数表.iloc[i + 2][4]
        荷载信息['温度梯度升温T2'] = 参数表.iloc[i + 2][5]
        荷载信息['不均匀沉降'] = 参数表.iloc[i + 2][6]
    i = i+1


# 新建写入结果文件
result = open('reslut.mct', 'w')


# 定义版本号及单位
result.write('''*VERSION
8.9.5
   
*UNIT    ; Unit System
; FORCE, LENGTH, HEAT, TEMPER
KN   , M, KJ, C
   ''')


# 定义结构类型
result.write('''
*STRUCTYPE    ; Structure Type
; iSTYP, iMASS, iSMAS, bMASSOFFSET, bSELFWEIGHT, GRAV, TEMPER, bALIGNBEAM, bALIGNSLAB, bROTRIGID
0, 1, 1, NO, YES, 9.806, 0, NO, NO, NO
   ''')

# 定义钢筋材料特性
result.write('''
*REBAR-MATL-CODE    ; Rebar Material Code
; CONC_CODE, CONC_MDB, SRC_CODE, SRC_MDB
 JTG04(RC), HRB335, JTG04(RC), HRB335
''')

# 计算混凝土开裂刚度
纵向上缘钢筋 = str(桥面板['纵向上缘钢筋']).split('@')
纵向下缘钢筋 = str(桥面板['纵向下缘钢筋']).split('@')
E开裂 = 2.06e8*(3.14159*(float(纵向上缘钢筋[0])/1000)**2/4*(1000/float(纵向上缘钢筋[1]))
              +3.14159*(float(纵向下缘钢筋[0])/1000)**2/4*(1000/float(纵向下缘钢筋[1])))/(float(桥面板['桥面板厚度'])/1000)

# 定义材料特性
result.write('''
*MATERIAL    ; Material
1, STEEL, Q345  , 0, 0, , C, NO, 0.02, 1, JTG D64-2015(S),            , Q345          , NO, 2.06e+008
2, CONC , C50   , 0, 0, , C, NO, 0.05, 2, 3.4500e+007,   0.2, 1.0000e-005,     0,     0
3, CONC , C50-无收缩徐变  , 0, 0, , C, NO, 0.05, 2, 3.4500e+007,   0.2, 1.0000e-005,     0,     0
4, SRC  , C50-组合 , 0, 0, , C, NO, 0.05, 1, JTG D64-2015(S), , Q345 ,NO, 2.06e+008,2,3.4500e+007,0.2, 1.0000e-005,0,0
''')
result.write('5, SRC  , C50-开裂 , 0, 0, , C, NO, 0.05, 1, JTG D64-2015(S), , Q345 ,NO, 2.06e+008,2,'+str(int(E开裂))+
             ',0.2, 1.0000e-005,0,0')


# 定义时间依存材料及连接
result.write('''
*TDM-TYPE    ; Time Dependent Material
   NAME=C50, China(JTG3362-2018), 50000, 77.9, 1, 5, 3, 0

*TDM-LINK    ; Time Dependent Material Link
; iMAT, TDM-TYPE1(CREEP/SHRINKAGE), TDM-TYPE2(ELASTICITY)
    2, C50,  
''')


# 定义主梁截面特性
result.write('''
*SECTION    ; Section
''')
主梁横向间距 = str(总体信息['主梁横向间距']).split(',')
主梁横向间距 = [float(主梁横向间距[i]) for i in range(len(主梁横向间距))]

# 定义主梁顶板厚度位置
主梁顶板厚度 = str(主梁板厚['顶板厚度序列']).split(',')
主梁顶板厚度 = [float(主梁顶板厚度[i]) for i in range(len(主梁顶板厚度))]
顶板长度序列 = str(主梁板厚['顶板长度序列']).split(',')
顶板长度序列 = [float(顶板长度序列[i]) for i in range(len(顶板长度序列))]
顶板厚度位置0 = float(0)
顶板厚度位置 = []
for i in range(len(顶板长度序列)):
    顶板厚度位置0 = 顶板厚度位置0+顶板长度序列[i]
    顶板厚度位置.append(顶板厚度位置0)

# 定义主梁底板厚度位置
主梁底板厚度 = str(主梁板厚['底板厚度序列']).split(',')
主梁底板厚度 = [ float(主梁底板厚度[i]) for i in range(len(主梁底板厚度)) ]
底板长度序列 = str(主梁板厚['底板长度序列']).split(',')
底板长度序列 = [float(底板长度序列[i]) for i in range(len(底板长度序列))]
底板厚度位置0 = float(0)
底板厚度位置 = []
for i in range(len(底板长度序列)):
    底板厚度位置0 = 底板厚度位置0+底板长度序列[i]
    底板厚度位置.append(底板厚度位置0)

# 定义主梁腹板厚度位置
主梁腹板厚度 = str(主梁板厚['腹板厚度序列']).split(',')
主梁腹板厚度 = [ float(主梁腹板厚度[i]) for i in range(len(主梁腹板厚度)) ]
腹板长度序列 = str(主梁板厚['腹板长度序列']).split(',')
腹板长度序列 = [float(腹板长度序列[i]) for i in range(len(腹板长度序列))]
腹板厚度位置0 = float(0)
腹板厚度位置 = []
for i in range(len(腹板长度序列)):
    腹板厚度位置0 = 腹板厚度位置0 + 腹板长度序列[i]
    腹板厚度位置.append(腹板厚度位置0)

# 获取主梁纵肋位置序列
主梁腹板纵肋位置 = []
主梁腹板纵肋号 = []
for i in range(len(主梁腹板纵肋设置.loc[:]['板肋'])):
    主梁腹板纵肋位置0 = str(主梁腹板纵肋设置.loc[i]['纵向范围']).split(',')
    主梁腹板纵肋位置.append([])
    主梁腹板纵肋号.append([])
    for j in range(len(主梁腹板纵肋位置0)):
        主梁腹板纵肋位置1 = 主梁腹板纵肋位置0[j].split('-')
        主梁腹板纵肋位置1 = [float(主梁腹板纵肋位置1[k]) for k in range(len(主梁腹板纵肋位置1))]
        for k in range(len(主梁腹板纵肋位置1)):
            主梁腹板纵肋位置[i].append(主梁腹板纵肋位置1[k])
            主梁腹板纵肋号[i].append(int(主梁腹板纵肋设置.loc[i]['板肋']) if k ==1 else 0)


# 主梁截面类型编号
主梁截面位置总序列 = []
主梁截面位置总序列.extend(顶板厚度位置)
主梁截面位置总序列.extend(底板厚度位置)
主梁截面位置总序列.extend(腹板厚度位置)
for i in range(len(主梁腹板纵肋位置)):
    主梁截面位置总序列.extend(主梁腹板纵肋位置[i])
主梁截面位置总序列.sort()
主梁截面位置总序列_去重 = 列表去重(主梁截面位置总序列)

主梁截面特征 = []
for i in range(len(主梁截面位置总序列)):
    顶板下标 = 判断位置在序列中下标(主梁截面位置总序列_去重[i],顶板厚度位置)
    底板下标 = 判断位置在序列中下标(主梁截面位置总序列_去重[i],底板厚度位置)
    腹板下标 = 判断位置在序列中下标(主梁截面位置总序列_去重[i],腹板厚度位置)
    主梁截面特征0 = []
    主梁截面特征0.append(主梁顶板厚度[顶板下标])
    主梁截面特征0.append(主梁底板厚度[底板下标])
    主梁截面特征0.append(主梁腹板厚度[腹板下标])
    for j in range(len(主梁腹板纵肋位置)):
        主梁纵肋下标 = 判断位置在序列中下标(主梁截面位置总序列_去重[i],主梁腹板纵肋位置[j])
        主梁截面特征0.append(主梁腹板纵肋号[j][主梁纵肋下标])
    主梁截面特征.append(主梁截面特征0)
主梁截面特征_去重 = pd.DataFrame(主梁截面特征).drop_duplicates(subset=None, keep='first', inplace=False)

# 截面特性编号
截面号 = 1
# 定义左边主梁截面特性
左边主梁截面号 = []
左边主梁截面数 = 1
主梁纵肋样式字符串 = ''
主梁纵肋位置字符串 = ''
for i in range(主梁截面特征_去重.shape[0]):
    主梁纵肋样式字符串 = ''
    主梁纵肋位置字符串 = ''
    计数器 = 0
    for j in range(3,len(主梁截面特征_去重.iloc[0][:])):
        if 主梁截面特征_去重.iloc[i][j] > 0:
            计数器 = 计数器+1
            样式 = int(主梁截面特征_去重.iloc[i][j])-1
            样式字符串 = [主梁纵肋样式字符串, ',', 主梁腹板纵肋设置.loc[样式]['备注'], ', 0,'
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋宽度'] / 1000), ','
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋厚度'] / 1000), ', 0, 0, 0, 0, 0, 0']
            位置字符串 = [主梁纵肋位置字符串,',NO,' , str(float(主梁腹板纵肋设置.loc[样式]['距顶端距离']) / 1000),','
                ,主梁腹板纵肋设置.loc[样式]['备注'] ,', 1,' , 主梁腹板纵肋设置.loc[样式]['备注']]
            主梁纵肋样式字符串 = ''.join(样式字符串)
            主梁纵肋位置字符串 = ''.join(位置字符串)
    if 计数器 == 0:
        主梁纵肋样式字符串 = '0'
        主梁纵肋位置字符串 = '0'
    else:
        样式字符串 = [str(计数器),主梁纵肋样式字符串]
        位置字符串 = ['1, 1, 0, 腹板, 0,',str(计数器),',',str(计数器),主梁纵肋位置字符串]
        主梁纵肋样式字符串 = ''.join(样式字符串)
        主梁纵肋位置字符串 = ''.join(位置字符串)
    result.write(str(截面号) + ', COMPOSITE ,' + '左边主梁_' + str(左边主梁截面数) + ', CT, 0, 0, 0, 0, 0, 0, YES, NO, GI' + '\n')
    result.write('NO,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',0,' +
                 str(主梁横向间距[0] / 1000 - 主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁横向间距[0] / 1000 - 主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['上翼缘宽度'] / 1000 / 2) +',' + str(主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['下翼缘宽度'] / 1000 / 2) + ',' + str(主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[i][0] / 1000 - 主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][0] / 1000) + ',' + str(主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][2] / 1000) + '\n')
    result.write(主梁纵肋样式字符串+ '\n')
    result.write(主梁纵肋位置字符串+ '\n')
    result.write(str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) +
                 ',1,' + str(主梁横向间距[0] / 1000 + float(主梁横向间距[1]) / 1000 / 4) +
                 ',' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                 str(桥面板['桥面板厚度'] / 1000) + ',0.05,5.97101, 3.14, 0.31, 0.2, 1.2, NO, ,' + '\n')
    左边主梁截面号.append(截面号)
    左边主梁截面数 = 左边主梁截面数 + 1
    截面号 = 截面号 + 1

# 定义右边主梁截面特性
右边主梁截面号 = []
右边主梁截面数 = 1
主梁纵肋样式字符串 = ''
主梁纵肋位置字符串 = ''
for i in range(主梁截面特征_去重.shape[0]):
    主梁纵肋样式字符串 = ''
    主梁纵肋位置字符串 = ''
    计数器 = 0
    for j in range(3,len(主梁截面特征_去重.iloc[0][:])):
        if 主梁截面特征_去重.iloc[i][j] > 0:
            计数器 = 计数器+1
            样式 = int(主梁截面特征_去重.iloc[i][j])-1
            样式字符串 = [主梁纵肋样式字符串, ',', 主梁腹板纵肋设置.loc[样式]['备注'], ', 0,'
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋宽度'] / 1000), ','
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋厚度'] / 1000), ', 0, 0, 0, 0, 0, 0']
            位置字符串 = [主梁纵肋位置字符串,',NO,' , str(float(主梁腹板纵肋设置.loc[样式]['距顶端距离']) / 1000),','
                ,主梁腹板纵肋设置.loc[样式]['备注'] ,', 0,' , 主梁腹板纵肋设置.loc[样式]['备注']]
            主梁纵肋样式字符串 = ''.join(样式字符串)
            主梁纵肋位置字符串 = ''.join(位置字符串)
    if 计数器 == 0:
        主梁纵肋样式字符串 = '0'
        主梁纵肋位置字符串 = '0'
    else:
        样式字符串 = [str(计数器),主梁纵肋样式字符串]
        位置字符串 = ['1, 1, 0, 腹板, 0,',str(计数器),',',str(计数器),主梁纵肋位置字符串]
        主梁纵肋样式字符串 = ''.join(样式字符串)
        主梁纵肋位置字符串 = ''.join(位置字符串)
    result.write(str(截面号) + ', COMPOSITE ,' + '右边主梁_' + str(右边主梁截面数) + ', CT, 0, 0, 0, 0, 0, 0, YES, NO, GI' + '\n')
    result.write('NO,' + str(主梁横向间距[0] / 1000 + float(主梁横向间距[1]) / 1000 / 4) + ',0,' +
                 str(主梁横向间距[0] / 1000 - 主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁横向间距[0] / 1000 - 主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['上翼缘宽度'] / 1000 / 2) +',' + str(主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['下翼缘宽度'] / 1000 / 2) + ',' + str(主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[i][0] / 1000 - 主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][0] / 1000) + ',' + str(主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][2] / 1000) + '\n')
    result.write(主梁纵肋样式字符串+ '\n')
    result.write(主梁纵肋位置字符串+ '\n')
    result.write(str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) +
                 ',1,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) +
                 ',' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                 str(桥面板['桥面板厚度'] / 1000) + ',0.05,5.97101, 3.14, 0.31, 0.2, 1.2, NO, ,' + '\n')
    右边主梁截面号.append(截面号)
    右边主梁截面数 = 右边主梁截面数 + 1
    截面号 = 截面号 + 1

# 定义中主梁截面特性
中主梁截面号 = []
中主梁截面数 = 1
主梁纵肋样式字符串 = ''
主梁纵肋位置字符串 = ''
for i in range(主梁截面特征_去重.shape[0]):
    主梁纵肋样式字符串 = ''
    主梁纵肋位置字符串 = ''
    计数器 = 0
    for j in range(3,len(主梁截面特征_去重.iloc[0][:])):
        if 主梁截面特征_去重.iloc[i][j] > 0:
            计数器 = 计数器+1
            样式 = int(主梁截面特征_去重.iloc[i][j])-1
            样式字符串 = [主梁纵肋样式字符串, ',', 主梁腹板纵肋设置.loc[样式]['备注'], ', 0,'
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋宽度'] / 1000), ','
                ,str(主梁腹板纵肋设置.loc[样式]['加劲肋厚度'] / 1000), ', 0, 0, 0, 0, 0, 0']
            位置字符串 = [主梁纵肋位置字符串,',NO,' , str(float(主梁腹板纵肋设置.loc[样式]['距顶端距离']) / 1000),','
                ,主梁腹板纵肋设置.loc[样式]['备注'] ,', 2,' , 主梁腹板纵肋设置.loc[样式]['备注']]
            主梁纵肋样式字符串 = ''.join(样式字符串)
            主梁纵肋位置字符串 = ''.join(位置字符串)
    if 计数器 == 0:
        主梁纵肋样式字符串 = '0'
        主梁纵肋位置字符串 = '0'
    else:
        样式字符串 = [str(计数器),主梁纵肋样式字符串]
        位置字符串 = ['1, 1, 0, 腹板, 0,',str(计数器),',',str(计数器),主梁纵肋位置字符串]
        主梁纵肋样式字符串 = ''.join(样式字符串)
        主梁纵肋位置字符串 = ''.join(位置字符串)
    result.write(str(截面号) + ', COMPOSITE ,' + '中主梁_' + str(中主梁截面数) + ', CT, 0, 0, 0, 0, 0, 0, YES, NO, GI' + '\n')
    result.write('NO,' + str(主梁横向间距[1] / 1000 / 2) + ',0,' +
                 str(主梁横向间距[1] / 1000 / 4 - 主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁横向间距[1] / 1000 / 4 - 主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['上翼缘宽度'] / 1000 / 2) +',' + str(主梁['上翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['下翼缘宽度'] / 1000 / 2) + ',' + str(主梁['下翼缘宽度'] / 1000 / 2) +
                 ',' + str(主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[i][0] / 1000 - 主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][0] / 1000) + ',' + str(主梁截面特征_去重.iloc[i][1] / 1000) +
                 ',' + str(主梁截面特征_去重.iloc[i][2] / 1000) + '\n')
    result.write(主梁纵肋样式字符串+ '\n')
    result.write(主梁纵肋位置字符串+ '\n')
    result.write(str(主梁横向间距[1] / 1000 / 2) +',1,' + str(主梁横向间距[1] / 1000 / 2) +
                 ',' + str(主梁横向间距[1] / 1000 / 2) + ',' +str(桥面板['桥面板厚度'] / 1000) +
                 ',0.05,5.97101, 3.14, 0.31, 0.2, 1.2, NO, ,' + '\n')
    中主梁截面号.append(截面号)
    中主梁截面数 = 中主梁截面数 + 1
    截面号 = 截面号 + 1

# 定义小纵梁截面特性
小纵梁尺寸 = 小纵梁['小纵梁(HW型钢)'].split('×')
小纵梁半顶宽 = float(小纵梁尺寸[0])/1000/2
小纵梁顶板厚 = float(小纵梁尺寸[2])/1000
小纵梁腹板厚 = float(小纵梁尺寸[3])/1000
小纵梁腹板高 = float(小纵梁尺寸[1])/1000-2*小纵梁顶板厚
小纵梁截面号 = 截面号
result.write(str(截面号) + ', COMPOSITE ,' + '小纵梁'+ ', CT, 0, 0, 0, 0, 0, 0, YES, NO, GI' + '\n')
result.write('NO,' + str(float(主梁横向间距[1]) / 1000 / 2) + ',0,' + str(float(主梁横向间距[1]) / 1000 / 4 - 小纵梁半顶宽) +
              ',' + str(float(主梁横向间距[1]) / 1000 / 4 - 小纵梁半顶宽) + ',' + str(小纵梁半顶宽) +',' + str(小纵梁半顶宽) +
             ',' + str(小纵梁半顶宽) + ',' + str(小纵梁半顶宽) +',' + str(小纵梁腹板高) +',' +str(小纵梁顶板厚) +
             ',' + str(小纵梁顶板厚) + ',' + str(小纵梁腹板厚) + '\n')
result.write('0' + '\n')
result.write('0' + '\n')
result.write(str(float(主梁横向间距[1]) / 1000 / 2) + ',1,' + str(float(主梁横向间距[1]) / 1000 / 2) +',' +
             str(float(主梁横向间距[1]) / 1000 / 2) + ',' + str(桥面板['桥面板厚度'] / 1000)
             +',0.05,5.97101, 3.14, 0.31, 0.2, 1.2, NO, ,' + '\n')
截面号 = 截面号 + 1

# 定义横向联系桥面板截面特性
横梁总数 = len(逗号乘号分隔函数(横梁布置['横梁位置序列']))
横梁间距 = [float(逗号乘号分隔函数(横梁布置['横梁位置序列'])[i]) for i in range(横梁总数)]
端横梁_顶宽 = 横梁间距[0]+横梁间距[1]/2
端横梁_偏心 = 横梁间距[0]
横向联系顶宽 = [(横梁间距[i]/2+横梁间距[i+1]/2) for i in range(1,横梁总数-1)]
横向联系偏心 = [横梁间距[i]/2 for i in range(1,横梁总数-1)]
横向联系截面号 = []
横向联系截面数 = 1
for i in range(横梁总数-2):
    if i == 1:
        result.write(str(截面号) + ',PSC,' + '横向联系_' + str(横向联系截面数) + ',LT,0,1,1,' + str(
            横向联系偏心[i] / 1000) + ',0,0,YES,NO,PSCM' + '\n')
        result.write('NONE, NONE, NO, NO, NO, NO, NO, NO, NO, NO, NO' + '\n')
        result.write('YES, YES, 0.125, YES, 0.125,  YES, 0, YES, 0, YES, 0, YES, 0,  0,  YES, NO'+ '\n')
        result.write('NO, , NO, , , , , ,'+'\n')
        result.write('NO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0'+'\n')
        result.write('0,' + str(桥面板['桥面板厚度'] / 1000) + ', 0, 0, 0, 0, 0, 0, 0, 0'+ '\n')
        result.write('0,' + str(横向联系偏心[i] / 1000) + ', 0, 0, 0, 0'+ '\n')
        result.write(str(桥面板['桥面板厚度'] / 1000) + ', 0, 0, 0, 0, 0, 0, 0, 0'+ '\n')
        result.write('0,' + str(横向联系偏心[i] / 1000) + ', 0, 0, 0, 0'+ '\n')
        横向联系截面号.append(截面号)
        横向联系截面数 = 横向联系截面数 + 1
        截面号 = 截面号 + 1
    elif i >=2 and 横向联系顶宽[i] == 横向联系顶宽[i-1] and 横向联系偏心[i] == 横向联系偏心[i-1]:
        横向联系截面号.append(截面号)
    else:
        result.write(str(截面号) + ',PSC,' + '横向联系_' + str(横向联系截面数) + ',LT,0,1,1,' + str(
            横向联系偏心[i] / 1000) + ',0,0,YES,NO,PSCM' + '\n')
        result.write('NONE, NONE, NO, NO, NO, NO, NO, NO, NO, NO, NO' + '\n')
        result.write('YES, YES, 0, YES, 0,  YES, 0, YES, 0, YES, 0, YES, 0,  0,  YES, NO' + '\n')
        result.write('NO, , NO, , , , , ,' + '\n')
        result.write('NO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0' + '\n')
        result.write('0,' + str(桥面板['桥面板厚度'] / 1000) + ', 0, 0, 0, 0, 0, 0, 0, 0' + '\n')
        result.write('0,' + str(横向联系偏心[i] / 1000) + ', 0, 0, 0, 0' + '\n')
        result.write(str(桥面板['桥面板厚度'] / 1000) + ', 0, 0, 0, 0, 0, 0, 0, 0' + '\n')
        result.write('0,' + str(横向联系偏心[i] / 1000) + ', 0, 0, 0, 0' + '\n')
        横向联系截面号.append(截面号)
        横向联系截面数 = 横向联系截面数 + 1
        截面号 = 截面号 + 1

# 定义工字形横梁截面特性
工字形横梁号 = []
工字形端横梁号 = []
for i in range(len(工字形横梁.loc[:]['工字形横梁'])):
    if 工字形横梁.loc[i]['顶缘距主梁顶距离'] == 0:
        # 定义端横梁
        result.write(str(截面号) + ',COMPOSITE,' + '工字形横梁_' + str(i+1)+ ',LT,0,1,1,'+str(端横梁_偏心/1000)+',0,0,YES,NO,GI'+'\n')
        result.write('NO,' + str(端横梁_顶宽/1000) + ',0,0,'+ str(端横梁_偏心/1000-工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2) +
                     ',' + str(端横梁_偏心/1000) +',' + str(工字形横梁.loc[i]['上翼缘宽度'] / 1000 -端横梁_偏心/1000) +
                     ',' + str(工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2) +',' +str(工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2) +
                     ',' + str(工字形横梁.loc[i]['腹板高度'] / 1000) +',' +str(工字形横梁.loc[i]['上翼缘厚度'] / 1000) +
                     ',' +str(工字形横梁.loc[i]['下翼缘厚度'] / 1000) +',' +str(工字形横梁.loc[i]['腹板厚度'] / 1000) + '\n')
        result.write('0' + '\n')
        result.write('0' + '\n')
        result.write(str(端横梁_顶宽/1000) + ',1,' + str(端横梁_顶宽/1000) + ',' +str(端横梁_顶宽/1000) + ',' +
                     str(桥面板['桥面板厚度'] / 1000)+ ',0.05,5.97101, 3.14, 0.31, 0.2, 1.2, NO, ,' + '\n')
        工字形横梁号.append(截面号)
        工字形端横梁号.append(截面号)
        截面号 = 截面号 + 1
    else:
        result.write(str(截面号) + ', SOD ,' + '工字形横梁_' + str(i + 1) + ' , CT, 0, 0, 0, 0, 0, 0, YES, NO, SOD-I' + '\n')
        result.write('NO,'+str(工字形横梁.loc[i]['上翼缘宽度'] / 1000 / 2)+','+str(工字形横梁.loc[i]['上翼缘宽度'] / 1000 / 2)+
                     ','+str(工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2)+','+str(工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2)+','+
                    str(工字形横梁.loc[i]['腹板高度'] / 1000) + ','+str(工字形横梁.loc[i]['上翼缘厚度'] / 1000) + ',' +
                     str(工字形横梁.loc[i]['下翼缘厚度'] / 1000) + ',' +str(工字形横梁.loc[i]['腹板厚度'] / 1000) +',0,'+
                     str(工字形横梁.loc[i]['上翼缘宽度'] / 1000 / 2-工字形横梁.loc[i]['下翼缘宽度'] / 1000 / 2)+'\n')
        result.write('0' + '\n')
        result.write('0' + '\n')
        工字形横梁号.append(截面号)
        截面号 = 截面号 + 1

# 定义K形桁架式横梁截面特性
K形横梁号 = []
K形横梁数 = 1
for i in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
    for j in range(3):
        if j == 0:
            上横梁尺寸 = K形桁架式横梁.loc[i]['上横梁(HW型钢)'].split('×')
            上横梁半顶宽 = float(上横梁尺寸[0]) / 1000 / 2
            上横梁顶板厚 = float(上横梁尺寸[2]) / 1000
            上横梁腹板厚 = float(上横梁尺寸[3]) / 1000
            上横梁腹板高 = float(上横梁尺寸[1]) / 1000 - 2 * 上横梁顶板厚
            result.write(str(截面号) + ', SOD ,' + 'K形横梁_' + str(K形横梁数) + ' , CT, 0, 0, 0, 0, 0, 0, YES, NO, SOD-I' + '\n')
            result.write('NO,' + str(上横梁半顶宽) + ',' + str(上横梁半顶宽) +',' + str(上横梁半顶宽) + ',' + str(上横梁半顶宽) +
                         ',' +str(上横梁腹板高) + ',' + str(上横梁顶板厚) + ',' +str(上横梁顶板厚) + ',' + str(上横梁腹板厚) +
                         ',0,0' + '\n')
            result.write('0' + '\n')
            result.write('0' + '\n')
            K形横梁号.append(截面号)
            K形横梁数 = K形横梁数 + 1
            截面号 = 截面号 + 1
        elif j == 1:
            下横梁尺寸 = K形桁架式横梁.loc[i]['下横梁(HW型钢)'].split('×')
            下横梁半顶宽 = float(下横梁尺寸[0]) / 1000 / 2
            下横梁顶板厚 = float(下横梁尺寸[2]) / 1000
            下横梁腹板厚 = float(下横梁尺寸[3]) / 1000
            下横梁腹板高 = float(下横梁尺寸[1]) / 1000 - 2 * 下横梁顶板厚
            result.write(str(截面号) + ', SOD ,' + 'K形横梁_' + str(K形横梁数) + ' , CT, 0, 0, 0, 0, 0, 0, YES, NO, SOD-I' + '\n')
            result.write('NO,' + str(下横梁半顶宽) + ',' + str(下横梁半顶宽) +',' + str(下横梁半顶宽) + ',' + str(下横梁半顶宽) +
                         ',' +str(下横梁腹板高) + ',' + str(下横梁顶板厚) + ',' +str(下横梁顶板厚) + ',' + str(下横梁腹板厚) +
                         ',0,0'+ '\n')
            result.write('0' + '\n')
            result.write('0' + '\n')
            K形横梁号.append(截面号)
            K形横梁数 = K形横梁数 + 1
            截面号 = 截面号 + 1
        elif j == 2:
            斜撑尺寸 = K形桁架式横梁.loc[i]['斜撑(F型钢)'].split('×')
            斜撑高 = float(斜撑尺寸[0]) / 1000 / 2
            斜撑宽 = float(斜撑尺寸[1]) / 1000 / 2
            斜撑板厚 = float(斜撑尺寸[2]) / 1000
            result.write(str(截面号) + ', DBUSER ,' + 'K形横梁_'+ str(K形横梁数) + ',CC, 0, 0, 0, 0, 0, 0, YES, NO, B , 2,'+
                         str(斜撑高)+','+str(斜撑宽)+','+str(斜撑板厚)+',' +str(斜撑板厚)+',' +str(斜撑宽-斜撑板厚)+',' +str(斜撑板厚)
                         +', 0, 0, 0, 0'+'\n')
            K形横梁号.append(截面号)
            K形横梁数 = K形横梁数 + 1
            截面号 = 截面号 + 1
K形横梁号P = np.array(K形横梁号).reshape(len(K形桁架式横梁.loc[:]['K形桁架式横梁']),3)

# 定义主梁节点
result.write('''
*NODE    ; Nodes
; iNO, X, Y, Z
''')
# 获取主梁横肋位置
横梁位置 = 相对位置转绝对(横梁间距)
主梁横肋位置 = []
主梁横肋位置0 = float(0)
for i in range(len(横梁位置)-1):
    if i == 0 or i == len(横梁位置)-2:
        for j in range(int(主梁腹板横肋设置['端横梁间横肋数'])):
            主梁横肋位置0 = 横梁位置[i] + (j+1)*(横梁位置[i+1]-横梁位置[i])/(int(主梁腹板横肋设置['端横梁间横肋数'])+1)
            主梁横肋位置.append(主梁横肋位置0)
    else:
        for j in range(int(主梁腹板横肋设置['其他横梁间横肋数'])):
            主梁横肋位置0 = 横梁位置[i] + (j+1)*(横梁位置[i+1]-横梁位置[i])/(int(主梁腹板横肋设置['其他横梁间横肋数'])+1)
            主梁横肋位置.append(主梁横肋位置0)

# 获取主梁分段位置
主梁分段位置 = str(主梁['主梁加工分段序列']).split(',')
主梁分段位置 = [float(主梁分段位置[i]) for i in range(len(主梁分段位置))]
主梁分段位置 = 相对位置转绝对(主梁分段位置)

# 获取主梁支座及支座加劲肋位置
支座位置0 = [float(支座布置.loc[i]['支座距离序列']) for i in range(支座布置.shape[0])]
支座位置 = 相对位置转绝对(支座位置0)
支座加劲肋位置 = []
每处加劲肋数量 = []
for i in range(支座布置.shape[0]):
    支座加劲肋位置0 = str(支座布置.loc[i]['支座加劲肋位置序列']).split(',')
    支座加劲肋位置0 = [(支座位置[i] + float(支座加劲肋位置0[j])) for j in range(len(支座加劲肋位置0))]
    每处加劲肋数量.append(len(支座加劲肋位置0))
    支座加劲肋位置.extend(支座加劲肋位置0)

# 主梁开裂截面位置
主梁开裂截面位置 = []
for i in  range(len(支座位置)-2):
    主梁开裂截面位置0 = 支座位置[i+1] - 0.15 * 支座位置0[i+1]
    主梁开裂截面位置1 = 支座位置[i + 1] + 0.15 * 支座位置0[i + 2]
    主梁开裂截面位置.append(主梁开裂截面位置0)
    主梁开裂截面位置.append(主梁开裂截面位置1)


# 获得主梁节点X坐标总序列
主梁节点X坐标总序列 = []
主梁节点X坐标总序列.extend(主梁截面位置总序列_去重)
主梁节点X坐标总序列.extend(横梁位置)
主梁节点X坐标总序列.extend(主梁横肋位置)
主梁节点X坐标总序列.extend(主梁分段位置)
主梁节点X坐标总序列.extend(支座加劲肋位置)
主梁节点X坐标总序列.extend(主梁开裂截面位置)
主梁节点X坐标总序列.sort()
主梁节点X坐标总序列 = 列表去重(主梁节点X坐标总序列)

# 定义主梁节点
NODE = int(1)
NL0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NL = []
for i in range(len(主梁节点X坐标总序列)):
    主梁节点Y坐标 = float(0)
    for j in range(总体信息['主梁片数']):
        主梁节点Y坐标 = 主梁节点Y坐标 + 主梁横向间距[j]
        NL0 = {'iNO': NODE, 'X': 主梁节点X坐标总序列[i]/1000, 'Y':主梁节点Y坐标/1000 , 'Z': 0}
        NL.append(NL0)
        NODE = NODE + 1
        result.write('  ' + str(NL0['iNO']) + ',' + str(NL0['X']) + ',' + str(NL0['Y']) + ',' + str(NL0['Z']) + '\n')
NLP = np.array(NL).reshape(len(主梁节点X坐标总序列), 总体信息['主梁片数'])

# 定义小纵梁节点
NZL0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NZL = []
for i in range(len(横梁位置)):
    小纵梁节点Y坐标 = int(0)
    for j in range(总体信息['主梁片数']-1):
        小纵梁节点Y坐标 = (主梁横向间距[0] + 主梁横向间距[1]/2) if j == 0 else (小纵梁节点Y坐标 + 主梁横向间距[j]/2 +主梁横向间距[j+1]/2)
        NZL0 = {'iNO': NODE, 'X': 横梁位置[i]/1000, 'Y':小纵梁节点Y坐标/1000 , 'Z': 0}
        NZL.append(NZL0)
        NODE = NODE + 1
        result.write('  ' + str(NZL0['iNO']) + ',' + str(NZL0['X']) + ',' + str(NZL0['Y']) + ',' + str(NZL0['Z']) + '\n')
NZLP = np.array(NZL).reshape(len(横梁位置),总体信息['主梁片数']-1)

# 定义横向联系桥面板挑臂节点(含端横梁节点)
NCD0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NCD = []
for i in range(len(横梁位置)):
    挑臂节点Y坐标 = float(0)
    for j in range(2):
        挑臂节点Y坐标 = 挑臂节点Y坐标 + j*float(总体信息['桥面宽度'])
        NCD0 = {'iNO': NODE, 'X': 横梁位置[i]/1000, 'Y':挑臂节点Y坐标/1000 , 'Z': 0}
        NCD.append(NCD0)
        NODE = NODE + 1
        result.write('  ' + str(NCD0['iNO']) + ',' + str(NCD0['X']) + ',' + str(NCD0['Y']) + ',' + str(NCD0['Z']) + '\n')
NCDP = np.array(NCD).reshape(len(横梁位置),2)

# 定义工字形横梁节点(不含端横梁)
NCB0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NCB = []
横梁样式 = [逗号乘号分隔函数(横梁布置['横梁样式序列'])[i] for i in range(横梁总数)]
工字形横梁总道数 = int(0)
工字形横梁样式总序列 = []
工字形横梁位置总序列 = []
# 统计工字形横梁总道数
for i in range(len(横梁位置)):
    if 横梁样式[i].find('工') != -1:
        工字形横梁总道数 = 工字形横梁总道数 +1
        工字形横梁样式总序列.append(横梁样式[i])
        工字形横梁位置总序列.append(横梁位置[i])
# 获取主梁小纵梁横向间距
主梁小纵梁横向间距 = []
for i in range(len(主梁横向间距)):
    if i == 0 or i == len(主梁横向间距)-1:
        主梁小纵梁横向间距.append(主梁横向间距[i])
    else:
        主梁小纵梁横向间距.append(主梁横向间距[i] / 2)
        主梁小纵梁横向间距.append(主梁横向间距[i] / 2)
# 生成工字形横梁节点
for i in range(工字形横梁总道数-2):
    X坐标 = 工字形横梁位置总序列[i+1]
    Y坐标 = float(0)
    for j in range(2*总体信息['主梁片数']-1):
        Y坐标 = Y坐标 + 主梁小纵梁横向间距[j]
        for k in range(len(工字形横梁.loc[:]['工字形横梁'])):
            if 工字形横梁样式总序列[i+1] == 工字形横梁.loc[k]['工字形横梁']:
                Z坐标 = -float(工字形横梁.loc[k]['顶缘距主梁顶距离'])
                NCB0 = {'iNO': NODE, 'X': X坐标 / 1000, 'Y': Y坐标 / 1000, 'Z': Z坐标 / 1000}
                NCB.append(NCB0)
                NODE = NODE + 1
                result.write('  ' + str(NCB0['iNO']) + ',' + str(NCB0['X']) + ',' + str(NCB0['Y']) + ',' + str(
                    NCB0['Z']) + '\n')
NCBP = np.array(NCB).reshape(工字形横梁总道数-2,2*总体信息['主梁片数']-1)

# 定义K形横梁节点
K形横梁总道数 = int(0)
K形横梁样式总序列 = []
K形横梁位置总序列 = []
# 统计工字形横梁总道数
for i in range(len(横梁位置)-2):
    if 横梁样式[i+1].find('K') != -1:
        K形横梁总道数 = K形横梁总道数 +1
        K形横梁样式总序列.append(横梁样式[i+1])
        K形横梁位置总序列.append(横梁位置[i + 1])
# 定义K形横梁上层节点
NKS0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NKS = []
for i in range(K形横梁总道数):
    X坐标 = K形横梁位置总序列[i]
    Y坐标 = float(0)
    for j in range(2*总体信息['主梁片数']-1):
        Y坐标 = Y坐标 + 主梁小纵梁横向间距[j]
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                Z坐标 = -float(K形桁架式横梁.loc[k]['上横梁顶距主梁顶距离'])
                NKS0 = {'iNO': NODE, 'X': X坐标 / 1000, 'Y': Y坐标 / 1000, 'Z': Z坐标 / 1000}
                NKS.append(NKS0)
                NODE = NODE + 1
                result.write('  ' + str(NKS0['iNO']) + ',' + str(NKS0['X']) + ',' + str(NKS0['Y']) + ',' + str(
                    NKS0['Z']) + '\n')
NKSP = np.array(NKS).reshape(K形横梁总道数,2*总体信息['主梁片数']-1)
# 定义K形横梁下层节点
NKX0 = {'iNO':NODE, 'X':0.0,'Y':0.0,'Z':0.0}
NKX = []
for i in range(K形横梁总道数):
    X坐标 = K形横梁位置总序列[i]
    Y坐标 = float(0)
    for j in range(总体信息['主梁片数']):
        Y坐标 = Y坐标 + 主梁横向间距[j]
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                Z坐标 = -float(K形桁架式横梁.loc[k]['下横梁顶距主梁顶距离'])
                NKX0 = {'iNO': NODE, 'X': X坐标 / 1000, 'Y': Y坐标 / 1000, 'Z': Z坐标 / 1000}
                NKX.append(NKX0)
                NODE = NODE + 1
                result.write('  ' + str(NKX0['iNO']) + ',' + str(NKX0['X']) + ',' + str(NKX0['Y']) + ',' + str(
                    NKX0['Z']) + '\n')
NKXP = np.array(NKX).reshape(K形横梁总道数,总体信息['主梁片数'])

# 定义上支座节点
NZS0 = {'iNO': NODE, 'X': 0.0, 'Y': 0.0, 'Z': 0.0}
NZS = []
for i in range(len(支座位置)):
    X坐标 = 支座位置[i]
    Y坐标 = float(0)
    Z坐标 = -桥面板['桥面板厚度'] - 主梁['钢主梁高度'] - 50
    for j in range(总体信息['主梁片数']):
        Y坐标 = Y坐标 + 主梁横向间距[j]
        NZS0 = {'iNO': NODE, 'X': X坐标 / 1000, 'Y': Y坐标 / 1000, 'Z': Z坐标 / 1000}
        NZS.append(NZS0)
        NODE = NODE + 1
        result.write(
            '  ' + str(NZS0['iNO']) + ',' + str(NZS0['X']) + ',' + str(NZS0['Y']) + ',' + str(NZS0['Z']) + '\n')
NZSP = np.array(NZS).reshape(len(支座位置), 总体信息['主梁片数'])

# 定义下支座节点
NZX0 = {'iNO': NODE, 'X': 0.0, 'Y': 0.0, 'Z': 0.0}
NZX = []
for i in range(len(支座位置)):
    X坐标 = 支座位置[i]
    Y坐标 = float(0)
    Z坐标 = -桥面板['桥面板厚度'] - 主梁['钢主梁高度'] - 350
    for j in range(总体信息['主梁片数']):
        Y坐标 = Y坐标 + 主梁横向间距[j]
        NZX0 = {'iNO': NODE, 'X': X坐标 / 1000, 'Y': Y坐标 / 1000, 'Z': Z坐标 / 1000}
        NZX.append(NZX0)
        NODE = NODE + 1
        result.write(
            '  ' + str(NZX0['iNO']) + ',' + str(NZX0['X']) + ',' + str(NZX0['Y']) + ',' + str(NZX0['Z']) + '\n')
NZXP = np.array(NZX).reshape(len(支座位置), 总体信息['主梁片数'])

# 定义主梁单元
result.write('''
*ELEMENT    ; Elements
''')
ELEMENT = int(1)
EL0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
EL = []
for i in range(len(主梁节点X坐标总序列)-1):
    # 获取主梁截面特性号
    位置下标 = 判断位置在序列中下标(主梁节点X坐标总序列[i],主梁截面位置总序列_去重)
    主梁截面特征_去重下标 = 获取主梁截面特征去重下标(主梁截面特征[位置下标], 主梁截面特征_去重)
    # 获取主梁材料号
    开裂下标 = 判断位置在序列中下标(主梁节点X坐标总序列[i],主梁开裂截面位置)
    iMAT = 4 if 开裂下标 % 2 == 0 else 5
    for j in range(总体信息['主梁片数']):
        if j == 0:
            EL0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': iMAT, 'iPRO': 左边主梁截面号[主梁截面特征_去重下标],
                   'iN1': NLP[i, j]['iNO'], 'iN2': NLP[i + 1, j]['iNO'], 'ANGLE': 0, 'iSUB': 0}
        elif j == 总体信息['主梁片数'] - 1:
            EL0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': iMAT, 'iPRO': 右边主梁截面号[主梁截面特征_去重下标],
                   'iN1': NLP[i, j]['iNO'], 'iN2': NLP[i + 1, j]['iNO'], 'ANGLE': 0, 'iSUB': 0}
        else:
            EL0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': iMAT, 'iPRO': 中主梁截面号[主梁截面特征_去重下标],
                   'iN1': NLP[i, j]['iNO'], 'iN2': NLP[i + 1, j]['iNO'], 'ANGLE': 0, 'iSUB': 0}
        EL.append(EL0)
        ELEMENT = ELEMENT + 1
        result.write('  ' + str(EL0['iEL']) + ',' + str(EL0['TYPE']) + ',' + str(EL0['iMAT']) + ',' + str(EL0['iPRO']) + ',' +
            str(EL0['iN1']) + ',' + str(EL0['iN2']) + ',' + str(EL0['ANGLE']) + ',' + str(EL0['iSUB']) + '\n')
ELP = np.array(EL).reshape(len(主梁节点X坐标总序列)-1,总体信息['主梁片数'])


# 定义小纵梁单元
EZL0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
EZL = []
for i in range(len(横梁位置)-1):
    for j in range(总体信息['主梁片数'] - 1):
        EZL0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': iMAT, 'iPRO': 小纵梁截面号,
                'iN1': NZLP[i, j]['iNO'], 'iN2': NZLP[i + 1, j]['iNO'], 'ANGLE': 0, 'iSUB': 0}
        EZL.append(EZL0)
        ELEMENT = ELEMENT + 1
        result.write('  ' + str(EZL0['iEL']) + ',' + str(EZL0['TYPE']) + ',' + str(EZL0['iMAT']) + ',' + str(
            EZL0['iPRO']) + ',' +
                     str(EZL0['iN1']) + ',' + str(EZL0['iN2']) + ',' + str(EZL0['ANGLE']) + ',' + str(
            EZL0['iSUB']) + '\n')
EZLP = np.array(EZL).reshape(len(横梁位置)-1,总体信息['主梁片数']-1)


# 定义端横梁及桥面板横向联系单元
ECD0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
ECD = []
for i in range(len(横梁位置)):
    主梁节点X下标 = 判断位置在序列中下标(NCDP[i,0]['X']*1000,主梁节点X坐标总序列)
    for j in range(2*总体信息['主梁片数']):
        if j == 0:
            iN1 = NCDP[i, 0]['iNO']
            iN2 = NLP[主梁节点X下标, 0]['iNO']
        elif j == 2*总体信息['主梁片数']-1:
            iN1 = NLP[主梁节点X下标, 总体信息['主梁片数'] - 1]['iNO']
            iN2 = NCDP[i, 1]['iNO']
        elif (j+1) % 2 == 0 and j != 2*总体信息['主梁片数']-1:
            iN1 = NLP[主梁节点X下标,int((j - 1)/2)]['iNO']
            iN2 = NZLP[i, int((j - 1)/2)]['iNO']
        else:
            iN1 = NZLP[i,int( j /2 - 1)]['iNO']
            iN2 = NLP[主梁节点X下标, int(j / 2)]['iNO']
        # 区分端横梁与其他横向联系
        if i == 0:
            ECD0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 4, 'iPRO': 工字形横梁号[0],
                    'iN1': iN2, 'iN2': iN1, 'ANGLE': 0, 'iSUB': 0}
        elif i == len(横梁位置) - 1:
            ECD0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 4, 'iPRO': 工字形横梁号[0],
                    'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
        else:
            ECD0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 3, 'iPRO': 横向联系截面号[i - 1],
                    'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
        ECD.append(ECD0)
        ELEMENT = ELEMENT + 1
        result.write(
            '  ' + str(ECD0['iEL']) + ',' + str(ECD0['TYPE']) + ',' + str(ECD0['iMAT']) + ',' + str(ECD0['iPRO']) +
            ',' + str(ECD0['iN1']) + ',' + str(ECD0['iN2']) + ',' + str(ECD0['ANGLE']) + ',' + str(
                ECD0['iSUB']) + '\n')
ECDP = np.array(ECD).reshape(len(横梁位置),2*总体信息['主梁片数'])


# 定义工字形横梁单元
ECB0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
ECB = []
for i in range(工字形横梁总道数-2):
    for j in range(2*总体信息['主梁片数']-2):
        iN1 = NCBP[i, j ]['iNO']
        iN2 = NCBP[i, j+1]['iNO']
        for k in range(len(工字形横梁.loc[:]['工字形横梁'])):
            if 工字形横梁样式总序列[i+1] == 工字形横梁.loc[k]['工字形横梁']:
                ECB0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 1, 'iPRO': 工字形横梁号[k],
                        'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
                ECB.append(ECB0)
                ELEMENT = ELEMENT + 1
                result.write('  ' + str(ECB0['iEL']) + ',' + str(ECB0['TYPE']) + ',' + str(ECB0['iMAT']) + ',' + str(
                    ECB0['iPRO']) +
                             ',' + str(ECB0['iN1']) + ',' + str(ECB0['iN2']) + ',' + str(ECB0['ANGLE']) + ',' + str(
                    ECB0['iSUB']) + '\n')
ECBP = np.array(ECB).reshape(工字形横梁总道数-2,2*总体信息['主梁片数']-2)


# 定义K形横梁上弦杆
EKS0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
EKS = []
for i in range(K形横梁总道数):
    for j in range(2*总体信息['主梁片数']-2):
        iN1 = NKSP[i, j ]['iNO']
        iN2 = NKSP[i, j+1]['iNO']
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                EKS0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 1, 'iPRO': K形横梁号P[k,0],
                        'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
                EKS.append(EKS0)
                ELEMENT = ELEMENT + 1
                result.write('  ' + str(EKS0['iEL']) + ',' + str(EKS0['TYPE']) + ',' + str(EKS0['iMAT']) + ',' + str(
                    EKS0['iPRO']) +
                             ',' + str(EKS0['iN1']) + ',' + str(EKS0['iN2']) + ',' + str(EKS0['ANGLE']) + ',' + str(
                    EKS0['iSUB']) + '\n')
EKSP = np.array(EKS).reshape(K形横梁总道数,2*总体信息['主梁片数']-2)


# 定义K形横梁下弦杆
EKX0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
EKX = []
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']-1):
        iN1 = NKXP[i, j ]['iNO']
        iN2 = NKXP[i, j+1]['iNO']
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                EKX0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 1, 'iPRO': K形横梁号P[k,1],
                        'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
                EKX.append(EKX0)
                ELEMENT = ELEMENT + 1
                result.write('  ' + str(EKX0['iEL']) + ',' + str(EKX0['TYPE']) + ',' + str(EKX0['iMAT']) + ',' + str(
                    EKX0['iPRO']) +
                             ',' + str(EKX0['iN1']) + ',' + str(EKX0['iN2']) + ',' + str(EKX0['ANGLE']) + ',' + str(
                    EKX0['iSUB']) + '\n')
EKXP = np.array(EKX).reshape(K形横梁总道数,总体信息['主梁片数']-1)


# 定义K形横梁斜杆
EK0 = {'iEL':ELEMENT,'TYPE':'BEAM','iMAT':0,'iPRO':0,'iN1':0,'iN2':0,'ANGLE':0,'iSUB':0}
EK = []
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']-1):
        iN1 = NKXP[i, j]['iNO']
        iN2 = NKSP[i, 2*j+1]['iNO']
        iN3 = NKXP[i, j+1]['iNO']
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                # 输出第1根斜杆
                EK0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 1, 'iPRO': K形横梁号P[k,2],
                        'iN1': iN1, 'iN2': iN2, 'ANGLE': 0, 'iSUB': 0}
                EK.append(EK0)
                ELEMENT = ELEMENT + 1
                result.write('  ' + str(EK0['iEL']) + ',' + str(EK0['TYPE']) + ',' + str(EK0['iMAT']) + ',' + str(
                    EK0['iPRO']) +
                             ',' + str(EK0['iN1']) + ',' + str(EK0['iN2']) + ',' + str(EK0['ANGLE']) + ',' + str(
                    EK0['iSUB']) + '\n')
                # 输出第2根斜杆
                EK0 = {'iEL': ELEMENT, 'TYPE': 'BEAM', 'iMAT': 1, 'iPRO': K形横梁号P[k, 2],
                       'iN1': iN2, 'iN2': iN3, 'ANGLE': 0, 'iSUB': 0}
                EK.append(EK0)
                ELEMENT = ELEMENT + 1
                result.write('  ' + str(EK0['iEL']) + ',' + str(EK0['TYPE']) + ',' + str(EK0['iMAT']) + ',' + str(
                    EK0['iPRO']) +
                             ',' + str(EK0['iN1']) + ',' + str(EK0['iN2']) + ',' + str(EK0['ANGLE']) + ',' + str(
                    EK0['iSUB']) + '\n')
EKP = np.array(EK).reshape(K形横梁总道数,2*总体信息['主梁片数']-2)

# 定义结构组
result.write('''
*GROUP    ; Group
; NAME, NODE_LIST, ELEM_LIST, PLANE_TYPE
''')

# 定义主梁结构组
result.write('主梁 , , '+' \\'+'\n')
result.write(str(ELP[0, 0]['iEL']) + ' to ' + str(ELP[len(主梁节点X坐标总序列)-2, 总体信息['主梁片数']-1]['iEL']) + ' \\' + '\n')
result.write(',0'+'\n')

# 定义小纵梁结构组
result.write('小纵梁 , , '+' \\'+'\n')
result.write(str(EZLP[0, 0]['iEL']) + ' to ' + str(EZLP[len(横梁位置)-2,总体信息['主梁片数']-2]['iEL']) + ' \\' + '\n')
result.write(',0'+'\n')
# 定义横梁结构组
result.write('横梁 , , '+' \\'+'\n')
result.write(str(ECDP[0, 0]['iEL']) + ' to ' + str(ECDP[0,2*总体信息['主梁片数']-1]['iEL']) + ' \\' + '\n')
result.write(str(ECDP[len(横梁位置)-1, 0]['iEL']) + ' to ' + str(ECDP[len(横梁位置)-1,2*总体信息['主梁片数']-1]['iEL']) + ' \\' + '\n')
result.write(str(ECBP[0, 0]['iEL']) + ' to ' + str(ECBP[工字形横梁总道数-3,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
if K形横梁总道数 > 0:
    result.write(str(EKSP[0, 0]['iEL']) + ' to ' + str(EKSP[K形横梁总道数-1,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
    result.write(str(EKXP[0, 0]['iEL']) + ' to ' + str(EKXP[K形横梁总道数-1,总体信息['主梁片数']-2]['iEL']) + ' \\' + '\n')
    result.write(str(EKP[0, 0]['iEL']) + ' to ' + str(EKP[K形横梁总道数-1,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
result.write(',0'+'\n')

# 定义横向联系结构组
result.write('横向联系 , , '+' \\'+'\n')
result.write(str(ECDP[0, 0]['iEL']) + ' to ' + str(ECDP[len(横梁位置)-1,2*总体信息['主梁片数']-1]['iEL']) + ' \\' + '\n')
result.write(str(ECBP[0, 0]['iEL']) + ' to ' + str(ECBP[工字形横梁总道数-3,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
if K形横梁总道数 > 0:
    result.write(str(EKSP[0, 0]['iEL']) + ' to ' + str(EKSP[K形横梁总道数-1,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
    result.write(str(EKXP[0, 0]['iEL']) + ' to ' + str(EKXP[K形横梁总道数-1,总体信息['主梁片数']-2]['iEL']) + ' \\' + '\n')
    result.write(str(EKP[0, 0]['iEL']) + ' to ' + str(EKP[K形横梁总道数-1,2*总体信息['主梁片数']-3]['iEL']) + ' \\' + '\n')
result.write(',0'+'\n')

# 定义支座结构组
result.write('支座 , '+' \\'+'\n')
result.write(str(NZSP[0, 0]['iNO'])+ ' to '+ str(NZSP[len(支座位置)-1, 总体信息['主梁片数'] - 1]['iNO'])+ ' \\'+'\n')
result.write(str(NZXP[0, 0]['iNO'])+ ' to '+ str(NZXP[len(支座位置)-1, 总体信息['主梁片数'] - 1]['iNO'])+ ' \\'+'\n')
result.write(', , 0'+'\n')


# 定义边界组
result.write('''
*BNDR-GROUP    ; Boundary Group
; NAME, AUTOTYPE
 主梁与横梁刚性连接, 0
 支座, 0
''')

# 定义荷载组
result.write('''
*LOAD-GROUP    ; Load Group
; NAME
 自重
 护栏荷载
 铺装荷载
 混凝土桥面板重
 横隔板重
 连接板重
 支座加劲肋重
 整体升温
 整体降温
 温度梯度升温
 温度梯度降温
''')

# 定义荷载工况
result.write('''
*STLDCASE    ; Static Load Cases
; LCNAME, LCTYPE, DESC
   自重, CS,
   护栏荷载, CS,
   铺装荷载, CS,
   混凝土桥面板重, CS,
   横隔板重, CS,
   连接板重, CS,
   支座加劲肋重, CS,
   整体升温 , T ,
   整体降温 , T , 
   温度梯度升温, TPG,
   温度梯度降温, TPG,
''')

# 定义边界条件
# 主梁与工字形横梁刚性连接
result.write('''
*RIGIDLINK    ; Rigid Link
''')
RLINK = {'M-NODE':0, 'DOF':'111111', 'S-NODE LIST':0, 'GROUP':'主梁与横梁刚性连接'}
for i in range(工字形横梁总道数-2):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if NLP[k, 0]['X'] == NCBP[i, 0]['X']:
                RLINK = {'M-NODE':NLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST':NCBP[i,2*j]['iNO'], 'GROUP':'主梁与横梁刚性连接'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 小纵梁与工字形横梁刚性连接
for i in range(工字形横梁总道数-2):
    for j in range(总体信息['主梁片数']-1):
        for k in range(len(横梁位置)):
            if NZLP[k, 0]['X'] == NCBP[i, 0]['X']:
                RLINK = {'M-NODE':NZLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST':NCBP[i,2*j+1]['iNO'], 'GROUP':'主梁与横梁刚性连接'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 主梁与K形横梁上横梁刚性连接
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if NLP[k, 0]['X'] == NKSP[i, 0]['X']:
                RLINK = {'M-NODE':NLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST': NKSP[i,2*j]['iNO'],'GROUP':'主梁与横梁刚性连接'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 小纵梁与K形横梁上横梁刚性连接
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']-1):
        for k in range(len(横梁位置)):
            if NZLP[k, 0]['X'] == NKSP[i, 0]['X']:
                RLINK = {'M-NODE':NZLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST': NKSP[i,2*j+1]['iNO'],'GROUP':'主梁与横梁刚性连接'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 主梁与K形横梁下横梁刚性连接
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if NLP[k, 0]['X'] == NKXP[i, 0]['X']:
                RLINK = {'M-NODE':NLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST':NKXP[i,j]['iNO'], 'GROUP':'主梁与横梁刚性连接'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 定义支座上节点与主梁刚性连接
for i in range(len(支座位置)):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if NLP[k, 0]['X'] == NZSP[i, 0]['X']:
                RLINK = {'M-NODE':NLP[k,j]['iNO'], 'DOF':'111111',
                         'S-NODE LIST':NZSP[i,j]['iNO'], 'GROUP':'支座'}
                result.write('  '+str(RLINK['M-NODE'])+','+RLINK['DOF']+','+str(RLINK['S-NODE LIST'])+','+RLINK['GROUP']+'\n')

# 定义支座下节点与上支座节点弹性连接
# 定义支座弹性连接
result.write('''
*ELASTICLINK    ; Elastic Link
''')
弹性连接号 = int(1)
ELINK = {'iNO':弹性连接号, 'iNODE1':0, 'iNODE2':0, 'LINK':'GEN', 'ANGLE':0,
         'R_SDx':'NO', 'R_SDy':'NO', 'R_SDz':'NO', 'R_SRx':'NO', 'R_SRy':'NO', 'R_SRz':'NO',
         'SDx':10000000, 'SDy':100000, 'SDz':100000, 'SRx':1, 'SRy':1, 'SRz':1 ,
         'bSHEAR':'NO', 'DRy':0.5, 'DRz':0.5, 'GROUP':'支座'}
for i in range(len(支座位置)):
    for j in range(总体信息['主梁片数']):
        ELINK = {'iNO': 弹性连接号, 'iNODE1': NZSP[i,j]['iNO'],'iNODE2': NZXP[i,j]['iNO'], 'LINK': 'GEN', 'ANGLE': 0,
                 'R_SDx': 'NO', 'R_SDy': 'NO', 'R_SDz': 'NO', 'R_SRx': 'NO', 'R_SRy': 'NO', 'R_SRz': 'NO',
                 'SDx': 1000000, 'SDy': 100000, 'SDz': 100000, 'SRx': 1, 'SRy': 1, 'SRz': 1,
                 'bSHEAR': 'NO', 'DRy': 0.5, 'DRz': 0.5, 'GROUP': '支座'}
        result.write('  ' + str(ELINK['iNO']) + ',' + str(ELINK['iNODE1']) + ',' + str(ELINK['iNODE2']) + ',' + str(
            ELINK['LINK']) + ',' + str(ELINK['ANGLE']) + ',' +
                     str(ELINK['R_SDx']) + ',' + str(ELINK['R_SDy']) + ',' + str(ELINK['R_SDz']) + ',' + str(
            ELINK['R_SRx']) + ',' + str(ELINK['R_SRy']) + ',' +
                     str(ELINK['R_SRz']) + ',' + str(ELINK['SDx']) + ',' + str(ELINK['SDy']) + ',' + str(
            ELINK['SDz']) + ',' + str(ELINK['SRx']) + ',' +
                     str(ELINK['SRy']) + ',' + str(ELINK['SRz']) + ',' + str(ELINK['bSHEAR']) + ',' + str(
            ELINK['DRy']) + ',' + str(ELINK['DRz']) + ',' + str(ELINK['GROUP']) + '\n')
        弹性连接号 = 弹性连接号 + 1

# 定义桩底支撑
result.write('''
*CONSTRAINT    ; Supports
; NODE_LIST, CONST(Dx,Dy,Dz,Rx,Ry,Rz), GROUP
''')
SUPPORT = {'NODE_LIST':0, 'CONST(Dx,Dy,Dz,Rx,Ry,Rz)':'111111', 'GROUP':'支座'}
for i in range(len(支座位置)):
   for j in range(总体信息['主梁片数']):
      SUPPORT = {'NODE_LIST': NZXP[i,j]['iNO'], 'CONST(Dx,Dy,Dz,Rx,Ry,Rz)': '111111','GROUP': '支座'}
      result.write('  '+ str(SUPPORT['NODE_LIST'])+ ','+ str(SUPPORT['CONST(Dx,Dy,Dz,Rx,Ry,Rz)'])+ ','+
                   str(SUPPORT['GROUP'])+'\n')

# 定义自重
result.write('''
*USE-STLD, 自重
*SELFWEIGHT    ; Self Weight
; X, Y, Z, GROUP
0, 0, -1, 自重
''')

# 定义护栏荷载
result.write('''
*USE-STLD, 护栏荷载
*BEAMLOAD    ; Element Beam Loads
''')
护栏荷载 = {'ELEM_LIST':0, 'CMD':'BEAM', 'TYPE':'UNILOAD', 'DIR':'GZ', 'bPROJ':'NO', 'bECCEN':'YES','ECCDIR':'0, GY',
           'I-END':0,'J-END': 0, 'bJ-END':'NO', 'D1':0, 'P1':0,'D2':0, 'P2':0,'D3':0, 'P3':0, 'D4':0 ,'P4':0,
           'GROUP':'护栏荷载','ADDITIONAL':'NO, 0, 0, NO,'}
for j in [0,总体信息['主梁片数']-1]:
    for i in range(len(主梁节点X坐标总序列)-1):
        if j == 0:
            护栏荷载 = {'ELEM_LIST': ELP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'UNILOAD', 'DIR': 'GZ', 'bPROJ': 'NO',
                       'bECCEN': 'YES','ECCDIR': '0, GY', 'I-END': -主梁横向间距[0]/1000, 'J-END': -主梁横向间距[0]/1000, 'bJ-END': 'NO',
                       'D1': 0, 'P1': 荷载信息['护栏荷载'], 'D2': 1, 'P2': 荷载信息['护栏荷载'], 'D3': 0, 'P3': 0, 'D4': 0,
                       'P4': 0, 'GROUP': '护栏荷载', 'ADDITIONAL': 'NO, 0, 0, NO,'}
        else:
            护栏荷载 = {'ELEM_LIST': ELP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'UNILOAD', 'DIR': 'GZ', 'bPROJ': 'NO',
                       'bECCEN': 'YES','ECCDIR': '0, GY', 'I-END': 主梁横向间距[len(主梁横向间距)-1]/1000,
                       'J-END': 主梁横向间距[len(主梁横向间距)-1]/1000,'bJ-END': 'NO','D1': 0, 'P1': 荷载信息['护栏荷载'],
                       'D2': 1, 'P2': 荷载信息['护栏荷载'], 'D3': 0,'P3': 0, 'D4': 0,'P4': 0, 'GROUP': '护栏荷载',
                       'ADDITIONAL': 'NO, 0, 0, NO,'}
        result.write(
            '  ' + str(护栏荷载['ELEM_LIST']) + ',' + str(护栏荷载['CMD']) + ',' + str(护栏荷载['TYPE']) + ',' + str(
                护栏荷载['DIR']) + ',' + str(护栏荷载['bPROJ']) + ',' + str(护栏荷载['bECCEN']) + ',' + str(护栏荷载['ECCDIR']) +
            ',' + str(护栏荷载['I-END']) + ',' + str(护栏荷载['J-END']) + ',' + str(护栏荷载['bJ-END']) + ',' +
            str(护栏荷载['D1']) + ',' + str(护栏荷载['P1']) + ',' +str(护栏荷载['D2']) + ',' + str(护栏荷载['P2']) + ',' +
            str(护栏荷载['D3']) + ',' + str(护栏荷载['P3']) + ',' + str(护栏荷载['D4']) + ',' + str(护栏荷载['P4'])
            + ',' + str(护栏荷载['GROUP']) + ',' + str(护栏荷载['ADDITIONAL']) + '\n')

# 定义沥青铺装荷载
result.write('''
*USE-STLD, 铺装荷载
*BEAMLOAD    ; Element Beam Loads
''')
铺装荷载 = {'ELEM_LIST':0, 'CMD':'BEAM', 'TYPE':'UNILOAD', 'DIR':'GZ', 'bPROJ':'NO', 'bECCEN':'YES','ECCDIR':'0, GY',
           'I-END':0,'J-END': 0, 'bJ-END':'NO', 'D1':0, 'P1':0,'D2':0, 'P2':0,'D3':0, 'P3':0, 'D4':0 ,'P4':0,
           'GROUP':'铺装荷载','ADDITIONAL':'NO, 0, 0, NO,'}
for j in range(总体信息['主梁片数']):
    for i in range(len(主梁节点X坐标总序列)-1):
        铺装荷载 = {'ELEM_LIST': ELP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'UNILOAD', 'DIR': 'GZ', 'bPROJ': 'NO',
                       'bECCEN': 'YES','ECCDIR': '0, GY', 'I-END': 0,'J-END': 0,'bJ-END': 'NO','D1': 0, 'P1': 荷载信息['铺装荷载'],
                       'D2': 1, 'P2': 荷载信息['铺装荷载'], 'D3': 0,'P3': 0, 'D4': 0,'P4': 0, 'GROUP': '铺装荷载',
                       'ADDITIONAL': 'NO, 0, 0, NO,'}
        result.write(
            '  ' + str(铺装荷载['ELEM_LIST']) + ',' + str(铺装荷载['CMD']) + ',' + str(铺装荷载['TYPE']) + ',' + str(
                铺装荷载['DIR']) + ',' + str(铺装荷载['bPROJ']) + ',' + str(铺装荷载['bECCEN']) + ',' + str(铺装荷载['ECCDIR']) +
            ',' + str(铺装荷载['I-END']) + ',' + str(铺装荷载['J-END']) + ',' + str(铺装荷载['bJ-END']) + ',' +
            str(铺装荷载['D1']) + ',' + str(铺装荷载['P1']) + ',' +str(铺装荷载['D2']) + ',' + str(铺装荷载['P2']) + ',' +
            str(铺装荷载['D3']) + ',' + str(铺装荷载['P3']) + ',' + str(铺装荷载['D4']) + ',' + str(铺装荷载['P4'])
            + ',' + str(铺装荷载['GROUP']) + ',' + str(铺装荷载['ADDITIONAL']) + '\n')

# 定义混凝土桥面板重
result.write('''
*USE-STLD, 混凝土桥面板重
*BEAMLOAD    ; Element Beam Loads
''')
桥面板重 = {'ELEM_LIST':0, 'CMD':'BEAM', 'TYPE':'UNILOAD', 'DIR':'GZ', 'bPROJ':'NO', 'bECCEN':'YES','ECCDIR':'0, GY',
           'I-END':0,'J-END': 0, 'bJ-END':'NO', 'D1':0, 'P1':0,'D2':0, 'P2':0,'D3':0, 'P3':0, 'D4':0 ,'P4':0,
           'GROUP':'混凝土桥面板重','ADDITIONAL':'NO, 0, 0, NO,'}
混凝土桥面板重 = - (总体信息['桥面宽度']/1000 *桥面板['桥面板厚度']/1000) / 总体信息['主梁片数'] * 28
for j in range(总体信息['主梁片数']):
    for i in range(len(主梁节点X坐标总序列)-1):
        桥面板重 = {'ELEM_LIST': ELP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'UNILOAD', 'DIR': 'GZ', 'bPROJ': 'NO',
                       'bECCEN': 'YES','ECCDIR': '0, GY', 'I-END': 0,'J-END': 0,'bJ-END': 'NO','D1': 0,'P1': 混凝土桥面板重,
                       'D2': 1, 'P2': 混凝土桥面板重, 'D3': 0,'P3': 0, 'D4': 0,'P4': 0, 'GROUP': '混凝土桥面板重',
                       'ADDITIONAL': 'NO, 0, 0, NO,'}
        result.write(
            '  ' + str(桥面板重['ELEM_LIST']) + ',' + str(桥面板重['CMD']) + ',' + str(桥面板重['TYPE']) + ',' + str(
                桥面板重['DIR']) + ',' + str(桥面板重['bPROJ']) + ',' + str(桥面板重['bECCEN']) + ',' + str(桥面板重['ECCDIR']) +
            ',' + str(桥面板重['I-END']) + ',' + str(桥面板重['J-END']) + ',' + str(桥面板重['bJ-END']) + ',' +
            str(桥面板重['D1']) + ',' + str(桥面板重['P1']) + ',' +str(桥面板重['D2']) + ',' + str(桥面板重['P2']) + ',' +
            str(桥面板重['D3']) + ',' + str(桥面板重['P3']) + ',' + str(桥面板重['D4']) + ',' + str(桥面板重['P4'])
            + ',' + str(桥面板重['GROUP']) + ',' + str(桥面板重['ADDITIONAL']) + '\n')

# 定义主梁横隔板重
result.write('''
*USE-STLD, 横隔板重
*CONLOAD    ; Nodal Loads
; NODE_LIST, FX, FY, FZ, MX, MY, MZ, GROUP
''')
主梁横隔板尺寸 = 主梁腹板横肋设置['腹板横肋(长×宽×厚)'].split('×')
主梁横隔板尺寸 = [float(主梁横隔板尺寸[i]) for i in range(len(主梁横隔板尺寸))]
主梁横隔板重 = - 主梁横隔板尺寸[0] / 1000* 主梁横隔板尺寸[1] / 1000 * 主梁横隔板尺寸[2] / 1000 *78.5
for i in range(len(主梁横肋位置)):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if 主梁横肋位置[i] == 主梁节点X坐标总序列[k]:
                主梁横隔板 = {'NODE_LIST': NLP[k,j]['iNO'], 'FX': 0,'FY': 0,'FZ': 主梁横隔板重,
                    'MX': 0, 'MY': 0, 'MZ': 0, 'GROUP': '横隔板重'}
                result.write('  '+ str(主梁横隔板['NODE_LIST'])+ ','+ str(主梁横隔板['FX'])+ ','+ str(主梁横隔板['FY'])+ ','+
                             str(主梁横隔板['FZ'])+','+ str(主梁横隔板['MX'])+ ','+ str(主梁横隔板['MY'])+ ','+
                             str(主梁横隔板['MY'])+ ','+ str(主梁横隔板['GROUP'])+'\n')

# 定义主梁连接板重
result.write('''
*USE-STLD, 连接板重
*CONLOAD    ; Nodal Loads
; NODE_LIST, FX, FY, FZ, MX, MY, MZ, GROUP
''')
主梁连接板重 = 主梁['主梁一处拼接板重']
for i in range(len(主梁分段位置)):
    for j in range(总体信息['主梁片数']):
        for k in range(len(主梁节点X坐标总序列)):
            if 主梁分段位置[i] == 主梁节点X坐标总序列[k]:
                主梁连接板 = {'NODE_LIST': NLP[k,j]['iNO'], 'FX': 0,'FY': 0,'FZ': 主梁连接板重,
                    'MX': 0, 'MY': 0, 'MZ': 0, 'GROUP': '连接板重'}
                result.write('  '+ str(主梁连接板['NODE_LIST'])+ ','+ str(主梁连接板['FX'])+ ','+ str(主梁连接板['FY'])+ ','+
                             str(主梁连接板['FZ'])+','+ str(主梁连接板['MX'])+ ','+ str(主梁连接板['MY'])+ ','+
                             str(主梁连接板['MY'])+ ','+ str(主梁连接板['GROUP'])+'\n')

# 定义主梁支座加劲肋重
result.write('''
*USE-STLD, 支座加劲肋重
*CONLOAD    ; Nodal Loads
; NODE_LIST, FX, FY, FZ, MX, MY, MZ, GROUP
''')
加劲肋计数 = 0
for i in range(len(每处加劲肋数量)):
    支座加劲肋尺寸 = 支座布置.loc[i]['支座加劲肋(长×宽×厚)'].split('×')
    支座加劲肋尺寸 = [float(支座加劲肋尺寸[m]) for m in range(len(支座加劲肋尺寸))]
    支座加劲肋重 = - 支座加劲肋尺寸[0] / 1000 * 支座加劲肋尺寸[1] / 1000 * 支座加劲肋尺寸[2] / 1000 * 78.5
    for j in range(每处加劲肋数量[i]):
        加劲肋计数 = 加劲肋计数 +1
        for k in range(总体信息['主梁片数']):
            for l in range(len(主梁节点X坐标总序列)):
                if 支座加劲肋位置[加劲肋计数-1] == 主梁节点X坐标总序列[l]:
                    支座加劲肋 = {'NODE_LIST': NLP[l,k]['iNO'], 'FX': 0,'FY': 0,'FZ': 支座加劲肋重,
                        'MX': 0, 'MY': 0, 'MZ': 0, 'GROUP': '支座加劲肋重'}
                    result.write('  '+ str(支座加劲肋['NODE_LIST'])+ ','+ str(支座加劲肋['FX'])+ ','+ str(支座加劲肋['FY'])+ ','+
                                 str(支座加劲肋['FZ'])+','+ str(支座加劲肋['MX'])+ ','+ str(支座加劲肋['MY'])+ ','+
                                 str(支座加劲肋['MY'])+ ','+ str(支座加劲肋['GROUP'])+'\n')

# 定义工字形横梁横隔板重
result.write('''
*USE-STLD, 横隔板重
*BEAMLOAD    ; Element Beam Loads
''')
for i in range(len(横梁位置)):
    for j in range(2*总体信息['主梁片数']-2):
        for k in range(len(工字形横梁.loc[:]['工字形横梁'])):
            if 横梁样式[i] == 工字形横梁.loc[k]['工字形横梁']:
                工字形横梁X下标 = 判断位置在序列中下标(横梁位置[i],工字形横梁位置总序列)
                工横隔板位置 = 逗号乘号分隔函数(str(工字形横梁.loc[k]['腹板横肋间距序列']))
                工横隔板位置 = [float(工横隔板位置[l]) for l in range(len(工横隔板位置))]
                工横隔板位置 = 相对位置转绝对(工横隔板位置)
                工横隔板尺寸 = 工字形横梁.loc[k]['腹板横肋(长×宽×厚)'].split('×')
                工横隔板尺寸 = [float(工横隔板尺寸[m]) for m in range(len(工横隔板尺寸))]
                工横隔板重 = - 工横隔板尺寸[0] / 1000 * 工横隔板尺寸[1] / 1000 * 工横隔板尺寸[2] / 1000 * 78.5
                for n in range(int((len(工横隔板位置) + 1) / 2 - 1)):
                    D1 = 工横隔板位置[n] / 主梁小纵梁横向间距[j + 1] if j % 2 == 0 else \
                        (1-工横隔板位置[n] / 主梁小纵梁横向间距[j + 1])
                    if i == 0:
                        工横隔板 = {'ELEM_LIST': ECDP[i, j+1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': D1,
                                'P1': 工横隔板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '横隔板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    elif i == len(横梁位置)-1:
                        工横隔板 = {'ELEM_LIST': ECDP[i, j+1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':D1,
                                'P1': 工横隔板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '横隔板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    else:
                        工横隔板 = {'ELEM_LIST': ECBP[工字形横梁X下标-1, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ', 'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': D1,
                                'P1': 工横隔板重,'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                 'GROUP': '横隔板重','ADDITIONAL': 'NO, 0, 0, NO,'}
                    result.write(
                        '  ' + str(工横隔板['ELEM_LIST']) + ',' + str(工横隔板['CMD']) + ',' + str(工横隔板['TYPE']) + ',' + str(
                            工横隔板['DIR']) + ',' + str(工横隔板['bPROJ']) + ',' + str(工横隔板['bECCEN']) + ',' + str(
                            工横隔板['ECCDIR']) +',' + str(工横隔板['I-END']) + ',' + str(工横隔板['J-END']) + ',' + str(
                            工横隔板['bJ-END']) + ',' +str(工横隔板['D1']) + ',' + str(工横隔板['P1']) + ',' + str(
                            工横隔板['D2']) + ',' + str(工横隔板['P2']) + ',' +str(工横隔板['D3']) + ',' + str(
                            工横隔板['P3']) + ',' + str(工横隔板['D4']) + ',' + str(工横隔板['P4'])
                            + ',' + str(工横隔板['GROUP']) + ',' + str(工横隔板['ADDITIONAL']) + '\n')
                if i == 0  and j % 2 ==0:
                    工横隔板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                            'bPROJ': 'NO',
                            'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 1,
                            'P1': 工横隔板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                            'GROUP': '横隔板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                elif i == len(横梁位置) - 1 and j % 2 ==0:
                    工横隔板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                            'bPROJ': 'NO',
                            'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 1,
                            'P1': 工横隔板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                            'GROUP': '横隔板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                elif j % 2 ==0:
                    工横隔板 = {'ELEM_LIST': ECBP[工字形横梁X下标 - 1, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                            'bPROJ': 'NO',
                            'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':1,
                            'P1': 工横隔板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                            'GROUP': '横隔板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                result.write(
                    '  ' + str(工横隔板['ELEM_LIST']) + ',' + str(工横隔板['CMD']) + ',' + str(工横隔板['TYPE']) + ',' + str(
                        工横隔板['DIR']) + ',' + str(工横隔板['bPROJ']) + ',' + str(工横隔板['bECCEN']) + ',' + str(
                        工横隔板['ECCDIR']) + ',' + str(工横隔板['I-END']) + ',' + str(工横隔板['J-END']) + ',' + str(
                        工横隔板['bJ-END']) + ',' + str(工横隔板['D1']) + ',' + str(工横隔板['P1']) + ',' + str(
                        工横隔板['D2']) + ',' + str(工横隔板['P2']) + ',' + str(工横隔板['D3']) + ',' + str(
                        工横隔板['P3']) + ',' + str(工横隔板['D4']) + ',' + str(工横隔板['P4'])
                    + ',' + str(工横隔板['GROUP']) + ',' + str(工横隔板['ADDITIONAL']) + '\n')

# 定义工字形横梁连接板重
result.write('''
*USE-STLD, 连接板重
*BEAMLOAD    ; Element Beam Loads
''')
for i in range(len(横梁位置)):
    for j in range(2*总体信息['主梁片数']-2):
        for k in range(len(工字形横梁.loc[:]['工字形横梁'])):
            if 横梁样式[i] == 工字形横梁.loc[k]['工字形横梁']:
                工字形横梁X下标 = 判断位置在序列中下标(横梁位置[i], 工字形横梁位置总序列)
                工连接板重 = 工字形横梁.loc[k]['横梁一端拼接重']
                if j % 2 ==0:
                    if i == 0:
                        工连接板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 0,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    elif i == len(横梁位置)-1:
                        工连接板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 0,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    else:
                        工连接板 = {'ELEM_LIST': ECBP[工字形横梁X下标 - 1, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':0,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                else:
                    if i == 0:
                        工连接板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 1,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    elif i == len(横梁位置)-1:
                        工连接板 = {'ELEM_LIST': ECDP[i, j + 1]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 1,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                    else:
                        工连接板 = {'ELEM_LIST': ECBP[工字形横梁X下标 - 1, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':1,
                                'P1': 工连接板重, 'D2': 0, 'P2': 0, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                result.write(
                    '  ' + str(工连接板['ELEM_LIST']) + ',' + str(工连接板['CMD']) + ',' + str(工连接板['TYPE']) + ',' + str(
                        工连接板['DIR']) + ',' + str(工连接板['bPROJ']) + ',' + str(工连接板['bECCEN']) + ',' + str(
                        工连接板['ECCDIR']) + ',' + str(工连接板['I-END']) + ',' + str(工连接板['J-END']) + ',' + str(
                        工连接板['bJ-END']) + ',' + str(工连接板['D1']) + ',' + str(工连接板['P1']) + ',' + str(
                        工连接板['D2']) + ',' + str(工连接板['P2']) + ',' + str(工连接板['D3']) + ',' + str(
                        工连接板['P3']) + ',' + str(工连接板['D4']) + ',' + str(工连接板['P4'])
                    + ',' + str(工连接板['GROUP']) + ',' + str(工连接板['ADDITIONAL']) + '\n')

# 定义K形横梁上连接板重
result.write('''
*USE-STLD, 连接板重
*BEAMLOAD    ; Element Beam Loads
''')
for i in range(K形横梁总道数):
    for j in range(2*总体信息['主梁片数']-2):
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                K上端连接板重 = K形桁架式横梁.loc[k]['上横梁一端拼接重']
                K上中连接板重 = K形桁架式横梁.loc[k]['上横梁中间拼接1/2重']
                if j % 2 ==0:
                    K上连接板 = {'ELEM_LIST': EKSP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                                'bPROJ': 'NO',
                                'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':0,
                                'P1': K上端连接板重, 'D2': 1, 'P2': K上中连接板重, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                                'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                else:
                    K上连接板 = {'ELEM_LIST': EKSP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                             'bPROJ': 'NO',
                             'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1': 0,
                             'P1': K上中连接板重, 'D2': 1, 'P2': K上端连接板重, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                             'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                result.write(
                    '  ' + str(K上连接板['ELEM_LIST']) + ',' + str(K上连接板['CMD']) + ',' + str(K上连接板['TYPE']) + ',' + str(
                        K上连接板['DIR']) + ',' + str(K上连接板['bPROJ']) + ',' + str(K上连接板['bECCEN']) + ',' + str(
                        K上连接板['ECCDIR']) + ',' + str(K上连接板['I-END']) + ',' + str(K上连接板['J-END']) + ',' + str(
                        K上连接板['bJ-END']) + ',' + str(K上连接板['D1']) + ',' + str(K上连接板['P1']) + ',' + str(
                        K上连接板['D2']) + ',' + str(K上连接板['P2']) + ',' + str(K上连接板['D3']) + ',' + str(
                        K上连接板['P3']) + ',' + str(K上连接板['D4']) + ',' + str(K上连接板['P4'])
                    + ',' + str(K上连接板['GROUP']) + ',' + str(K上连接板['ADDITIONAL']) + '\n')

# 定义K形横梁下连接板重
result.write('''
*USE-STLD, 连接板重
*BEAMLOAD    ; Element Beam Loads
''')
for i in range(K形横梁总道数):
    for j in range(总体信息['主梁片数']-1):
        for k in range(len(K形桁架式横梁.loc[:]['K形桁架式横梁'])):
            if K形横梁样式总序列[i] == K形桁架式横梁.loc[k]['K形桁架式横梁']:
                K下端连接板重 = K形桁架式横梁.loc[k]['下横梁一端拼接重']
                K下连接板 = {'ELEM_LIST': EKXP[i, j]['iEL'], 'CMD': 'BEAM', 'TYPE': 'CONLOAD', 'DIR': 'GZ',
                            'bPROJ': 'NO',
                            'bECCEN': 'YES', 'ECCDIR': '0, GY', 'I-END': 0, 'J-END': 0, 'bJ-END': 'NO', 'D1':0,
                            'P1': K下端连接板重, 'D2': 1, 'P2': K下端连接板重, 'D3': 0, 'P3': 0, 'D4': 0, 'P4': 0,
                            'GROUP': '连接板重', 'ADDITIONAL': 'NO, 0, 0, NO,'}
                result.write(
                    '  ' + str(K下连接板['ELEM_LIST']) + ',' + str(K下连接板['CMD']) + ',' + str(K下连接板['TYPE']) + ',' + str(
                        K下连接板['DIR']) + ',' + str(K下连接板['bPROJ']) + ',' + str(K下连接板['bECCEN']) + ',' + str(
                        K下连接板['ECCDIR']) + ',' + str(K下连接板['I-END']) + ',' + str(K下连接板['J-END']) + ',' + str(
                        K下连接板['bJ-END']) + ',' + str(K下连接板['D1']) + ',' + str(K下连接板['P1']) + ',' + str(
                        K下连接板['D2']) + ',' + str(K下连接板['P2']) + ',' + str(K下连接板['D3']) + ',' + str(
                        K下连接板['P3']) + ',' + str(K下连接板['D4']) + ',' + str(K下连接板['P4'])
                    + ',' + str(K下连接板['GROUP']) + ',' + str(K下连接板['ADDITIONAL']) + '\n')

# 定义整体升温温度荷载
result.write('''
*USE-STLD, 整体升温
*ELTEMPER    ; Element Temperatures
; ELEM_LIST, TEMPER, GROUP
''')
for i in range(EZLP[len(横梁位置)-2,总体信息['主梁片数']-2]['iEL']):
   result.write(str(i+1)+','+str(荷载信息['整体升温'])+','+'整体升温'+'\n')

# 定义整体降温温度荷载
result.write('''
*USE-STLD, 整体降温
*ELTEMPER    ; Element Temperatures
; ELEM_LIST, TEMPER, GROUP
''')
for i in range(EZLP[len(横梁位置)-2,总体信息['主梁片数']-2]['iEL']):
   result.write(str(i+1)+','+str(荷载信息['整体降温'])+','+'整体降温'+'\n')


# 定义温度梯度升温
result.write('''
*USE-STLD, 温度梯度升温
*BSTEMPER    ; Beam Section Temperature
; ELEM_LIST, DIR, REF, NUM, GROUP, bPSC              ; line 1
;   TYPE1, ELAST1, THERMAL1, B1, H11, T11, H21, T21  ; line 2
;   ...
;   TYPEn, ELASTn, THERMALn, Bn, H1n, T1n, H2n, T2n  ; line n+1
;   TYPE, ELAST, THERMAL, REF, BOPT, B, H1OPT, H1, H2OPT, H2, T1, T2 ; line 2(PSC)
''')
# 主梁温度梯度升温
for i in range(len(主梁节点X坐标总序列)-1):
    # 获取主梁截面特性号
    位置下标 = 判断位置在序列中下标(主梁节点X坐标总序列[i], 主梁截面位置总序列_去重)
    主梁截面特征_去重下标 = 获取主梁截面特征去重下标(主梁截面特征[位置下标], 主梁截面特征_去重)
    for j in range(总体信息['主梁片数']):
        if j == 0:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度升温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0) + ',' + str(荷载信息['温度梯度升温T1']) + ',' + str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000+
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000+主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        elif j == 总体信息['主梁片数'] - 1:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度升温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0) + ',' + str(荷载信息['温度梯度升温T1']) + ',' + str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        else:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度升温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 /2) + ',' +
                         str(0) + ',' + str(荷载信息['温度梯度升温T1']) + ',' + str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 /2) + ',' +
                         str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')

# 小纵梁温度梯度升温
for i in range(len(横梁位置)-1):
    for j in range(总体信息['主梁片数']-1):
        result.write('  ' + str(EZLP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度升温, NO' + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 / 2) + ',' +
                     str(0) + ',' + str(荷载信息['温度梯度升温T1']) + ',' + str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 / 2) + ',' +
                     str(0.1) + ',' + str(荷载信息['温度梯度升温T2']) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                     str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                     ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                     str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                     str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁半顶宽 * 2) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
            ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚) + ',' +
            str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁腹板厚) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚) +
            ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高) + ',' +
            str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁半顶宽 * 2) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高) +
            ',' + str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高 + 小纵梁顶板厚) + ',' +
            str(float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')

# 定义温度梯度降温
result.write('''
*USE-STLD, 温度梯度降温
*BSTEMPER    ; Beam Section Temperature
; ELEM_LIST, DIR, REF, NUM, GROUP, bPSC              ; line 1
;   TYPE1, ELAST1, THERMAL1, B1, H11, T11, H21, T21  ; line 2
;   ...
;   TYPEn, ELASTn, THERMALn, Bn, H1n, T1n, H2n, T2n  ; line n+1
;   TYPE, ELAST, THERMAL, REF, BOPT, B, H1OPT, H1, H2OPT, H2, T1, T2 ; line 2(PSC)
''')
# 主梁温度梯度降温
for i in range(len(主梁节点X坐标总序列)-1):
    # 获取主梁截面特性号
    位置下标 = 判断位置在序列中下标(主梁节点X坐标总序列[i], 主梁截面位置总序列_去重)
    主梁截面特征_去重下标 = 获取主梁截面特征去重下标(主梁截面特征[位置下标], 主梁截面特征_去重)
    for j in range(总体信息['主梁片数']):
        if j == 0:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度降温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0) + ',' + str(-0.5*float(荷载信息['温度梯度升温T1'])) + ',' + str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000+
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300)  + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000+主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        elif j == 总体信息['主梁片数'] - 1:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度降温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0) + ',' + str(-0.5*float(荷载信息['温度梯度升温T1'])) + ',' + str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[0] / 1000 + 主梁横向间距[1] / 1000 / 4) + ',' +
                         str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        else:
            result.write('  ' + str(ELP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度降温, NO' + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 /2) + ',' +
                         str(0) + ',' + str(-0.5*float(荷载信息['温度梯度升温T1'])) + ',' + str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 /2) + ',' +
                         str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
            result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                         ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                         str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                         str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁截面特征_去重.iloc[主梁截面特征_去重下标][2] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
            result.write(
                '  INPUT,  2.06e+008, 1.2e-005,' + str(主梁['下翼缘宽度'] / 1000) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) +
                ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
                str(桥面板['桥面板厚度'] / 1000 + 0.05 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 +
                    主梁['钢主梁高度'] / 1000 - 主梁截面特征_去重.iloc[主梁截面特征_去重下标][0] / 1000 -
                    主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000 + 主梁截面特征_去重.iloc[主梁截面特征_去重下标][1] / 1000) + ',' +
                str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')

# 小纵梁温度梯度降温
for i in range(len(横梁位置)-1):
    for j in range(总体信息['主梁片数']-1):
        result.write('  ' + str(EZLP[i, j]['iEL']) + ', LZ, Top, 6, 温度梯度降温, NO' + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 / 2) + ',' +
                     str(0) + ',' + str(-0.5*float(荷载信息['温度梯度升温T1'])) + ',' + str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁横向间距[1] / 1000 / 2) + ',' +
                     str(0.1) + ',' + str(-0.5*float(荷载信息['温度梯度升温T2'])) + ',' + str(桥面板['桥面板厚度'] / 1000) + ',' +
                     str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + '\n')
        result.write('  INPUT, 3.45e+007, 1e-005,' + str(主梁['上翼缘宽度'] / 1000) + ',' + str(桥面板['桥面板厚度'] / 1000) +
                     ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] - 100.0)) / 300) + ',' +
                     str(桥面板['桥面板厚度'] / 1000 + 0.05) + ',' +
                     str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁半顶宽 * 2) + ',' + str(桥面板['桥面板厚度'] / 1000 + 0.05) +
            ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚) + ',' +
            str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁腹板厚) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚) +
            ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高) + ',' +
            str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')
        result.write(
            '  INPUT,  2.06e+008, 1.2e-005,' + str(小纵梁半顶宽 * 2) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高) +
            ',' + str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + ',' +
            str(桥面板['桥面板厚度'] / 1000 + 0.05 + 小纵梁顶板厚 + 小纵梁腹板高 + 小纵梁顶板厚) + ',' +
            str(-0.5*float(荷载信息['温度梯度升温T2']) * (300 - (桥面板['桥面板厚度'] + 50 - 100.0)) / 300) + '\n')

# 定义施工阶段
result.write('''
*STAGE    ; Define Construction Stage
  NAME=架设钢梁, 7, YES, NO, NO, 5
  AELEM=主梁, 0, 支座, 0
  ABNDR=支座, DEFORMED
  ALOAD=自重, FIRST, 横隔板重, FIRST, 连接板重, FIRST, 支座加劲肋重, FIRST
  NAME=安装横梁, 7, YES, NO, NO, 5
  AELEM=横梁, 0, 小纵梁, 0
  ABNDR=主梁与横梁刚性连接, DEFORMED
  NAME=浇筑桥面板, 7, YES, NO, NO, 5
  ALOAD=混凝土桥面板重, FIRST
  NAME=桥面板成型, 1, YES, NO, NO, 5
  AELEM=横向联系, 0
  NAME=二期施工, 7, YES, NO, NO, 5
  ALOAD=护栏荷载, FIRST, 铺装荷载, FIRST
  NAME=收缩徐变, 3650, YES, NO, NO, 5
''')

# 定义施工阶段联合截面
result.write('''
*CPOSECT4CS    ; Composite Section for Construction Stage
; SEC=SEC, ASTAGE, TYPE, bTAP                                                      // line 1
;     [PART-INFO]-1                                                                // from line 2
;     ...
;     [PART-INFO]-n
; [PART-INFO] : [COMMON], [SCALE], H, VS                                           // TYPE=A,B,NORMAL
; [COMMON]: PART, MTYPE, MAT, CSTAGE, AGE
; [SCALE] : AREA, ASY, ASZ, IXX, IYY, IZZ, WAREA
''')
联合截面号 = int(1)
# 左边主梁联合截面
for i in range(左边主梁截面数-1):
    result.write('  '+'SEC='+str(左边主梁截面号[i]) + ', 架设钢梁, NORMAL, NO' + '\n')
    result.write('  1, MATL, 1, , 0, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    result.write('  2, MATL, 2, 桥面板成型, 9, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    联合截面号 = 联合截面号 + 1

# 右边主梁联合截面
for i in range(右边主梁截面数-1):
    result.write('  '+'SEC='+str(右边主梁截面号[i]) + ', 架设钢梁, NORMAL, NO' + '\n')
    result.write('  1, MATL, 1, , 0, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    result.write('  2, MATL, 2, 桥面板成型, 9, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    联合截面号 = 联合截面号 + 1

# 中主梁联合截面
for i in range(中主梁截面数-1):
    result.write('  '+'SEC='+str(中主梁截面号[i]) + ', 架设钢梁, NORMAL, NO' + '\n')
    result.write('  1, MATL, 1, , 0, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    result.write('  2, MATL, 2, 桥面板成型, 9, 1, 1, 1, 1, 1, 1, 1'+ '\n')
    联合截面号 = 联合截面号 + 1

# 小纵梁联合截面
result.write('  '+'SEC='+str(小纵梁截面号) + ', 架设钢梁, NORMAL, NO' + '\n')
result.write('  1, MATL, 1, , 0, 1, 1, 1, 1, 1, 1, 1'+ '\n')
result.write('  2, MATL, 2, 桥面板成型, 9, 1, 1, 1, 1, 1, 1, 1'+ '\n')
联合截面号 = 联合截面号 + 1

# 工字形端横梁联合截面
工字形横梁号 = []
for i in range(len(工字形端横梁号)):
    result.write('  ' + 'SEC=' + str(工字形端横梁号[i]) + ', 安装横梁, NORMAL, NO' + '\n')
    result.write('  1, MATL, 1, , 0, 1, 1, 1, 1, 1, 1, 1' + '\n')
    result.write('  2, MATL, 2, 桥面板成型, 9, 1, 1, 1, 1, 1, 1, 1' + '\n')
    联合截面号 = 联合截面号 + 1


# 定义移动荷载规范
result.write('''
*MVLDCODE    ; Moving Load Code
; CODE=CODE
   CODE=CHINA
''')

# 定义车辆
result.write('''
*VEHICLE    ; Vehicles
   NAME=CH-CD, 1, CH-CD, JTGB01-2014
   NAME=CH-PL1, 1, CH-PL1, JTGB01-2014
   NAME=CH-PL2, 1, CH-PL2, JTGB01-2014, 40
''')

# 定义车道线
result.write('''
*LINELANE(CH)    ; Traffic Line Lanes (china)
; NAME=NAME, LDIST, GROUP, SKEWS, SKEWE, MOVING, WS, LW, bLANEOPT, ALLOWWIDTH     ; line 1
;      iELEM1, ECC1, SPAN1, bSPANSTART1, SF ...                                   ; from line 2
''')
# 获取车道数
行车道总宽 = 总体信息['桥面宽度']/1000  - 1.0
车道数 = int(0)
if 行车道总宽 < 7.0:
    车道数 = 1
elif 7.0 <= 行车道总宽 < 10.5:
    车道数 = 2
elif 10.5 <= 行车道总宽 < 14.0:
    车道数 = 3
elif 14.0 <= 行车道总宽 < 17.5:
    车道数 = 4
elif 17.5 <= 行车道总宽 < 21.0:
    车道数 = 5
elif 21.0 <= 行车道总宽 < 24.5:
    车道数 = 6
elif 24.5 <= 行车道总宽 < 28.0:
    车道数 = 7
elif 28.0 <= 行车道总宽:
    车道数 = 8

# 获取主梁最大跨度
最大跨度 = 0
for i in range(len(支座位置0)):
    if 支座位置0[i]/1000 > 最大跨度:
        最大跨度 = 支座位置0[i]/1000

# 定义左车道线
梁边距 = 主梁横向间距[0]/1000
车道偏距 = 0
for i in range(车道数):
    result.write('  NAME=左偏' + str(i+1) + ', CROSS, 横向联系, 0, 0, BOTH, 1.8,  , NO, 3' + '\n')
    if i == 0:
        车道偏距 = 梁边距 - 1.9
    else:
        车道偏距 = 车道偏距 - 3.1
    for j in range(len(主梁节点X坐标总序列)-1):
        if j == 0:
            result.write('  ' + str(ELP[j, 0]['iEL']) + ',' + str(车道偏距) + ',' + str(最大跨度) + ', YES, 1' + '\n')
        else:
            result.write('  ' + str(ELP[j, 0]['iEL']) + ',' + str(车道偏距) + ',' + str(最大跨度) + ', NO, 1' + '\n')

# 定义右车道线
车道偏距 = 0
for i in range(车道数):
    result.write('  NAME=右偏' + str(i+1) + ', CROSS, 横向联系, 0, 0, BOTH, 1.8,  , NO, 3' + '\n')
    if i == 0:
        车道偏距 = 1.9 - 梁边距
    else:
        车道偏距 = 车道偏距 + 3.1
    for j in range(len(主梁节点X坐标总序列)-1):
        if j == 0:
            result.write('  ' + str(ELP[j, 总体信息['主梁片数']-1]['iEL']) + ',' + str(车道偏距) + ',' + str(最大跨度) + ', YES, 1' + '\n')
        else:
            result.write('  ' + str(ELP[j, 总体信息['主梁片数']-1]['iEL']) + ',' + str(车道偏距) + ',' + str(最大跨度) + ', NO, 1' + '\n')

# 定义中车道线
车道偏距序列 = []
if 车道数 % 2 ==0:
    车道偏距0 = 0
    车道偏距1 = 0
    for i in range(int(车道数/2)):
        if i == 0:
            车道偏距0 = 梁边距 - 总体信息['桥面宽度']/1000/2  + 1.55
            车道偏距1 = 梁边距 - 总体信息['桥面宽度']/1000/2  - 1.55
            车道偏距序列.append(车道偏距0)
            车道偏距序列.append(车道偏距1)
        else:
            车道偏距0 = 车道偏距0 + 3.1
            车道偏距1 = 车道偏距1 - 3.1
            车道偏距序列.append(车道偏距0)
            车道偏距序列.append(车道偏距1)
else:
    车道偏距 = 0
    车道偏距0 = 0
    车道偏距1 = 0
    for i in range(int((车道数 +1)/ 2)):
        if i == 0:
            车道偏距 = 梁边距 - 总体信息['桥面宽度'] / 1000 / 2
            车道偏距序列.append(车道偏距)
        elif i == 1:
            车道偏距0 = 梁边距 - 总体信息['桥面宽度'] / 1000 / 2 + 3.1
            车道偏距1 = 梁边距 - 总体信息['桥面宽度'] / 1000 / 2 - 3.1
            车道偏距序列.append(车道偏距0)
            车道偏距序列.append(车道偏距1)
        else:
            车道偏距0 = 车道偏距0 + 3.1
            车道偏距1 = 车道偏距1 - 3.1
            车道偏距序列.append(车道偏距0)
            车道偏距序列.append(车道偏距1)
for i in range(车道数):
    result.write('  NAME=中载' + str(i+1) + ', CROSS, 横向联系, 0, 0, BOTH, 1.8,  , NO, 3' + '\n')
    for j in range(len(主梁节点X坐标总序列)-1):
        if j == 0:
            result.write('  ' + str(ELP[j, 0]['iEL']) + ',' + str(车道偏距序列[i]) + ',' + str(最大跨度) + ', YES, 1' + '\n')
        else:
            result.write('  ' + str(ELP[j, 0]['iEL']) + ',' + str(车道偏距序列[i]) + ',' + str(最大跨度) + ', NO, 1' + '\n')

# 定义移动荷载工况
result.write('''
*MVLDCASE(CH)   ; Moving Load Cases (china)
; NAME=NAME, DESC, bOPTIM, TYPE, COMB, SERIAL                                               ; 1st line
;      MSCALE1,   MSCALE2,   ... , MSCALE8                                                  ; 2nd line
;      GSCALE1,   GSCALE2,   ... , GSCALE8                                                  ; 3rd line
;      JTGSCALE1, JTGSCALE2, ... , JTGSCALE8                                                ; 4th line
;      TYPE1, VCLASS1, SCALE1, iMIN1, iMAX1, LANE11, LANE12, ...                            ; 5th line
;      ...                                                                                  ; ...
;      TYPEn, VCLASSn, SCALEn, iMINn, iMAXn, LANEn1, LANEn2, ...  
''')
# 定义左偏移动荷载工况
result.write('''
    NAME=左偏, , NO, 2, 1, 1
    1, 1, 0.8, 0.67, 0.6, 0.55, 0.55, 0.55
    1, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
    1.2, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
''')
result.write('  VL, CH-CD, 1.15, 0,' + str(车道数) +',\\'+'\n')
for i in range(车道数):
   if i == 车道数 - 1:
      result.write('左偏'+str(i+1)+'\n')
   else:
       result.write('左偏' + str(i + 1) + ',\\' + '\n')

# 定义右偏移动荷载工况
result.write('''
    NAME=右偏, , NO, 2, 1, 1
    1, 1, 0.8, 0.67, 0.6, 0.55, 0.55, 0.55
    1, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
    1.2, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
''')
result.write('  VL, CH-CD, 1.15, 0,' + str(车道数) +',\\'+'\n')
for i in range(车道数):
   if i == 车道数 - 1:
      result.write('右偏'+str(i+1)+'\n')
   else:
       result.write('右偏' + str(i + 1) + ',\\' + '\n')

# 定义中载移动荷载工况
result.write('''
    NAME=中载, , NO, 2, 1, 1
    1, 1, 0.8, 0.67, 0.6, 0.55, 0.55, 0.55
    1, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
    1.2, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
''')
result.write('  VL, CH-CD, 1.15, 0,' + str(车道数) +',\\'+'\n')
for i in range(车道数):
   if i == 车道数 - 1:
      result.write('中载'+str(i+1)+'\n')
   else:
       result.write('中载' + str(i + 1) + ',\\' + '\n')

# 定义疲劳车1移动荷载工况
result.write('''
    NAME=PL1, , NO, 2, 1, 1
    1, 1, 0.8, 0.67, 0.6, 0.55, 0.55, 0.55
    1, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
    1.2, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
''')
result.write('  VL, CH-PL1, 1.15, 0,' + str(车道数) +',\\'+'\n')
for i in range(车道数):
   if i == 车道数 - 1:
      result.write('中载'+str(i+1)+'\n')
   else:
       result.write('中载' + str(i + 1) + ',\\' + '\n')

# 定义疲劳车2移动荷载工况
result.write('''
    NAME=PL2, , NO, 2, 1, 1
    1, 1, 0.8, 0.67, 0.6, 0.55, 0.55, 0.55
    1, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
    1.2, 1, 0.78, 0.67, 0.6, 0.55, 0.52, 0.5
''')
result.write('  VL, CH-PL2, 1.15, 0,' + str(车道数) +',\\'+'\n')
for i in range(车道数):
   if i == 车道数 - 1:
      result.write('中载'+str(i+1)+'\n')
   else:
       result.write('中载' + str(i + 1) + ',\\' + '\n')

# 定义沉降荷载
result.write('''
*SM-GROUP    ; Settlement Group
; GRNAME, DISPLACEMENT, NODE_LIST
''')
for i in range(len(支座位置)):
    NODE_LIST = ' '
    for j in range(总体信息['主梁片数']):
        NODE_LIST0 = str(NZXP[i,j]['iNO'])
        NODE_LIST = NODE_LIST + '  ' + NODE_LIST0
    SM = {'GRNAME':i, 'DISPLACEMENT':-0.01,'NODE_LIST':NODE_LIST}
    result.write('     '+ str(SM['GRNAME'])+ ','+ str(SM['DISPLACEMENT'])+ ','+ str(SM['NODE_LIST'])+'\n')

# 定义沉降荷载工况
result.write('''
*SMLDCASE    ; Settlement Load Cases
; NAME=NAME, iSMIN, iSMAX, SCALE, DESC ; line 1
;      GRNAME1, GRNAME2, ...           ; from line 2

''')
result.write('  NAME=SETTLEMENT'+','+'1'+','+str(len(支座位置)-1)+','+'1'+','+'\n')
for i in range(len(支座位置)):
   if i == len(支座位置) - 1:
      result.write(str(i)+'\n')
   else:
      result.write(str(i)+',\\'+'\n')


# 施工阶段分析控制数据
result.write('''
*STAGE-CTRL    ; Construction Stage Analysis Control Data
  YES, , INTERNAL, NO, NO, YES, NO, NO, NO, NO, NO, , , NO, NO, , NO, NO, NO
  0 
  NO
  YES, YES, BOTH, 5, 0.01, YES, NO, YES, YES, 0, NO
  NO, NO, 2, YES, 2, 5, 7, 10, 20
  NO, , , 1, NO
''')

# 定义移动荷载分析控制数据
result.write('''
*MOVE-CTRL(CH)    ; Moving Load Analysis Control (china)
   INF, 0, 3, NODAL, YES, AXIAL, YES,   YES, NO, ,   YES, NO, ,   YES, NO, ,   YES, NO,   , YES, 0, 0, YES, 0
   1.8
''')

# 定义沉降分析控制数据
result.write('''
*SM-CTRL    ; Settlement Analysis Control Data
; bCONCURRENT, bCONCLINK                                          ; line 1
   NO, NO
''')

# 结束
result.write('''
*ENDDATA
''')

# 关闭写入文件
result.close()